diff --git a/.clang-tidy b/.clang-tidy
index c03da523..d16cc35c 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -29,16 +29,8 @@ Checks: >
         -modernize-avoid-c-arrays,
         -modernize-loop-convert,
         -modernize-pass-by-value,
-        -modernize-return-braced-init-list,
-        -modernize-use-auto,
-        -modernize-use-emplace,
-        -modernize-use-equals-default,
-        -modernize-use-equals-delete,
-        -modernize-use-default-member-init,
         -modernize-use-nodiscard,
-        -modernize-use-override,
         -modernize-use-trailing-return-type,
-        -modernize-use-using,
         -readability-avoid-nested-conditional-operator,
         -readability-braces-around-statements,
         -readability-function-cognitive-complexity,
@@ -48,10 +40,9 @@ Checks: >
         -readability-isolate-declaration,
         -readability-magic-numbers,
         -readability-redundant-inline-specifier,
-        -readability-simplify-boolean-expr,
+        -readability-use-concise-preprocessor-directives,
         -readability-uppercase-literal-suffix,
         -performance-avoid-endl,
-        -performance-enum-size,
         -performance-inefficient-string-concatenation,
         -performance-no-automatic-move,
         -performance-noexcept-move-constructor
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 00000000..bd256eb3
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,16 @@
+#
+# This file lists revisions that should be ignored when considering
+# attribution for the actual code written.  Code style changes should
+# not be considered as modifications with regards to attribution.
+#
+# To see clean and meaningful blame information.
+# $ git blame important.py --ignore-revs-file .git-blame-ignore-revs
+#
+# To configure git to automatically ignore revisions listed in a file
+# on every call to git blame.
+# $ git config blame.ignoreRevsFile .git-blame-ignore-revs
+#
+# Ignore changes introduced when doing global file format changes
+
+# Switch to uncrustify (#517)
+cfd179711f413aa8e0da9c2f437ad4f8938d5f70
diff --git a/.github/workflows/CI-mingw.yml b/.github/workflows/CI-mingw.yml
new file mode 100644
index 00000000..a3bac5cf
--- /dev/null
+++ b/.github/workflows/CI-mingw.yml
@@ -0,0 +1,138 @@
+name: CI-mingw
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: msys2 {0}
+
+jobs:
+  build:
+
+    strategy:
+      matrix:
+        compiler: [g++, clang++]
+        # TODO: add MSYS after #556 is fixed
+        msystem: [MINGW32, MINGW64, CLANG64]
+        include:
+          #- msystem: MSYS
+          #  pkg-prefix: ''
+          - msystem: MINGW32
+            pkg-prefix: 'mingw-w64-i686-'
+          - msystem: MINGW64
+            pkg-prefix: 'mingw-w64-x86_64-'
+          - msystem: CLANG64
+            pkg-prefix: 'mingw-w64-clang-x86_64-'
+          - compiler: g++
+            compiler-pkg: gcc
+          - compiler: clang++
+            compiler-pkg: clang
+        exclude:
+          - msystem: CLANG64
+            compiler: g++
+      fail-fast: false
+
+    runs-on: windows-2025
+
+    env:
+      CXX: ${{ matrix.compiler }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          release: false # use pre-installed
+          msystem: ${{ matrix.msystem }}
+          # TODO: install mingw-w64-x86_64-make and use mingw32.make instead - currently fails with "Windows Subsystem for Linux has no installed distributions."
+          # TODO: also run tests with non-prefixed Python?
+          install: >-
+            make
+            ${{ matrix.pkg-prefix }}cmake
+            ${{ matrix.pkg-prefix }}python
+            ${{ matrix.pkg-prefix }}python-pytest
+
+      - name: install compiler
+        run: |
+          pacman -S --noconfirm ${{ matrix.pkg-prefix }}${{ matrix.compiler-pkg }}
+          ${CXX} -v
+
+      - name: make simplecpp
+        run: |
+          make -j$(nproc) CXXOPTS="-Werror"
+
+      # gcc *and* clang are required to run-tests.py
+      # install it at this point since it has gcc as dependency which might interfere with the build
+      - name: install compiler (clang)
+        if: matrix.compiler == 'g++'
+        run: |
+          pacman -S --noconfirm clang
+
+      - name: install compiler (gcc)
+        if: matrix.compiler == 'clang++'
+        run: |
+          pacman -S --noconfirm gcc
+
+      - name: make test
+        run: |
+          # TODO: run tests with Windows paths
+          make -j$(nproc) test
+
+      - name: selfcheck
+        run: |
+          # TODO: run tests with Windows paths
+          make -j$(nproc) selfcheck
+
+      - name: make (c++14)
+        run: |
+          make clean
+          make -j$(nproc) CXXOPTS="-Werror -std=c++14"
+
+      - name: make (c++17)
+        run: |
+          make clean
+          make -j$(nproc) CXXOPTS="-Werror -std=c++17"
+
+      - name: make (c++20)
+        run: |
+          make clean
+          make -j$(nproc) CXXOPTS="-Werror -std=c++20"
+
+      - name: make (c++23)
+        run: |
+          make clean
+          make -j$(nproc) CXXOPTS="-Werror -std=c++23"
+
+      - name: Run CMake
+        run: |
+          cmake -S . -B cmake.output -DCMAKE_COMPILE_WARNING_AS_ERROR=On
+
+      - name: CMake simplecpp
+        run: |
+          cmake --build cmake.output --target simplecpp -- -j $(nproc)
+
+      - name: CMake testrunner
+        run: |
+          cmake --build cmake.output --target testrunner -- -j $(nproc)
+
+      - name: Run testrunner
+        run: |
+          ./cmake.output/testrunner
+
+      - name: Run with libstdc++ debug mode
+        if: matrix.compiler == 'g++'
+        run: |
+          make clean
+          make -j$(nproc) test selfcheck CXXOPTS="-Werror -g3 -D_GLIBCXX_DEBUG"
+
+      - name: Run with libc++ hardening mode
+        if: matrix.compiler == 'clang++' && matrix.msystem == 'CLANG64'
+        run: |
+          make clean
+          make -j$(nproc) test selfcheck CXXOPTS="-Werror -stdlib=libc++ -g3 -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG" LDOPTS="-lc++"
diff --git a/.github/workflows/CI-unixish.yml b/.github/workflows/CI-unixish.yml
index 050e1d74..6fd8a429 100644
--- a/.github/workflows/CI-unixish.yml
+++ b/.github/workflows/CI-unixish.yml
@@ -2,13 +2,21 @@ name: CI-unixish
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
 jobs:
   build:
 
     strategy:
       matrix:
-        compiler: [clang++, g++]
-        os: [ubuntu-20.04, ubuntu-22.04, ubuntu-24.04, macos-13, macos-14]
+        os: [ubuntu-22.04, ubuntu-24.04, macos-14, macos-15, macos-15-intel, macos-26]
+        compiler: [clang++]
+        include:
+          - os: ubuntu-22.04
+            compiler: g++
+          - os: ubuntu-24.04
+            compiler: g++
       fail-fast: false
 
     runs-on: ${{ matrix.os }}
@@ -17,7 +25,17 @@ jobs:
       CXX: ${{ matrix.compiler }}
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
+      with:
+        persist-credentials: false
+
+    # the man-db trigger causes package installations to stall for several minutes at times. so just drop the package.
+    # see https://github.com/actions/runner/issues/4030
+    - name: Remove man-db package on ubuntu
+      if: matrix.os == 'ubuntu-24.04'
+      run: |
+        sudo apt-get update
+        sudo apt-get remove man-db
 
     - name: Install missing software on ubuntu
       if: matrix.os == 'ubuntu-24.04'
@@ -25,25 +43,58 @@ jobs:
           sudo apt-get update
           sudo apt-get install valgrind
 
+    # llvm contains llvm-profdata
     - name: Install missing software on ubuntu (clang++)
-      if: matrix.os == 'ubuntu-24.04' && matrix.compiler == 'clang++'
+      if: contains(matrix.os, 'ubuntu') && matrix.compiler == 'clang++'
       run: |
         sudo apt-get update
-        sudo apt-get install libc++-18-dev
-          
+        sudo apt-get install libc++-dev llvm
+
+      # coreutils contains "nproc"
+    - name: Install missing software on macos
+      if: contains(matrix.os, 'macos')
+      run: |
+        brew install coreutils
+
+    - name: Install missing Python packages
+      run: |
+        python3 -m pip config set global.break-system-packages true
+        python3 -m pip install pytest
+
     - name: make simplecpp
-      run: make -j$(nproc)
+      run: make -j$(nproc) CXXOPTS="-Werror"
 
     - name: make test
-      run: make -j$(nproc) test
+      run: make -j$(nproc) test CXXOPTS="-Werror"
 
     - name: selfcheck
       run: |
         make -j$(nproc) selfcheck
 
+    - name: make (c++14)
+      run: |
+        make clean
+        make -j$(nproc) CXXOPTS="-Werror -std=c++14"
+
+    - name: make (c++17)
+      run: |
+        make clean
+        make -j$(nproc) CXXOPTS="-Werror -std=c++17"
+
+    - name: make (c++20)
+      run: |
+        make clean
+        make -j$(nproc) CXXOPTS="-Werror -std=c++20"
+
+    - name: make (c++23)
+      run: |
+        make clean
+        # ubuntu-22.04 and macos-14 do not support c++23 yet
+        make -j$(nproc) CXXOPTS="-Werror -std=c++2b"
+
     - name: Run CMake
       run: |
-        cmake -S . -B cmake.output
+        cmake -S . -B cmake.output -Werror=dev --warn-uninitialized -DCMAKE_COMPILE_WARNING_AS_ERROR=On
 
     - name: CMake simplecpp
       run: |
@@ -53,44 +104,91 @@ jobs:
       run: |
         cmake --build cmake.output --target testrunner -- -j $(nproc)
         ./cmake.output/testrunner
+        # Re-run tests from within the build directory to validate that
+        # SIMPLECPP_TEST_SOURCE_DIR is correctly defined and resolved
+        (cd cmake.output && ./testrunner)
 
     - name: Run valgrind
       if: matrix.os == 'ubuntu-24.04'
       run: |
           make clean
-          make -j$(nproc)
+          make -j$(nproc) CXXOPTS="-O1"
           valgrind --leak-check=full --num-callers=50 --show-reachable=yes --track-origins=yes --gen-suppressions=all --error-exitcode=42 ./testrunner
-          valgrind --leak-check=full --num-callers=50 --show-reachable=yes --track-origins=yes --gen-suppressions=all --error-exitcode=42 ./simplecpp simplecpp.cpp -e
+          # TODO: run Python tests with valgrind
+          VALGRIND_TOOL=memcheck ./selfcheck.sh
 
     - name: Run with libstdc++ debug mode
       if: matrix.os == 'ubuntu-24.04' && matrix.compiler == 'g++'
       run: |
         make clean
-        make -j$(nproc) test selfcheck CXXFLAGS="-g3 -D_GLIBCXX_DEBUG"
+        make -j$(nproc) test selfcheck CXXOPTS="-Werror -g3 -D_GLIBCXX_DEBUG"
 
     - name: Run with libc++ hardening mode
       if: matrix.os == 'ubuntu-24.04' && matrix.compiler == 'clang++'
       run: |
         make clean
-        make -j$(nproc) test selfcheck CXXFLAGS="-stdlib=libc++ -g3 -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG" LDFLAGS="-lc++"
+        make -j$(nproc) test selfcheck CXXOPTS="-Werror -stdlib=libc++ -g3 -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG" LDOPTS="-lc++"
 
     - name: Run AddressSanitizer
-      if: matrix.os == 'ubuntu-24.04'
+      if: matrix.os == 'ubuntu-24.04' || matrix.os == 'macos-26'
       run: |
         make clean
-        make -j$(nproc) test selfcheck CXXFLAGS="-O2 -g3 -fsanitize=address" LDFLAGS="-fsanitize=address"
+        make -j$(nproc) test selfcheck CXXOPTS="-Werror -O2 -g3 -fsanitize=address" LDOPTS="-fsanitize=address"
       env:
         ASAN_OPTIONS: detect_stack_use_after_return=1
 
     - name: Run UndefinedBehaviorSanitizer
-      if: matrix.os == 'ubuntu-24.04'
+      if: matrix.os == 'ubuntu-24.04' || matrix.os == 'macos-26'
       run: |
         make clean
-        make -j$(nproc) test selfcheck CXXFLAGS="-O2 -g3 -fsanitize=undefined -fno-sanitize=signed-integer-overflow" LDFLAGS="-fsanitize=undefined -fno-sanitize=signed-integer-overflow"
+        make -j$(nproc) test selfcheck CXXOPTS="-Werror -O2 -g3 -fsanitize=undefined -fno-sanitize=signed-integer-overflow" LDOPTS="-fsanitize=undefined -fno-sanitize=signed-integer-overflow"
+      env:
+        UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1:report_error_type=1
 
     # TODO: requires instrumented libc++
     - name: Run MemorySanitizer
       if: false && matrix.os == 'ubuntu-24.04' && matrix.compiler == 'clang++'
       run: |
         make clean
-        make -j$(nproc) test selfcheck CXXFLAGS="-O2 -g3 -stdlib=libc++ -fsanitize=memory" LDFLAGS="-lc++ -fsanitize=memory"
+        make -j$(nproc) test selfcheck CXXOPTS="-Werror -O2 -g3 -stdlib=libc++ -fsanitize=memory" LDOPTS="-lc++ -fsanitize=memory"
+
+    - name: Run callgrind
+      if: matrix.os == 'ubuntu-24.04'
+      run: |
+        wget https://github.com/danmar/simplecpp/archive/refs/tags/1.5.1.tar.gz
+        tar xvf 1.5.1.tar.gz
+        rm -f 1.5.1.tar.gz
+        
+        make clean
+        make -j$(nproc) CXXOPTS="-O2 -g3" simplecpp
+        VALGRIND_TOOL=callgrind SIMPLECPP_PATH=simplecpp-1.5.1 ./selfcheck.sh >callgrind.log || (cat callgrind.log && false)
+        cat callgrind.log
+        
+        # PGO - start
+        make clean
+        make -j$(nproc) CXXOPTS="-O2 -g3 -fprofile-generate" LDOPTS="-fprofile-generate" simplecpp
+        SIMPLECPP_PATH=simplecpp-1.5.1 ./selfcheck.sh >/dev/null
+        
+        if compgen -G "default_*.profraw" > /dev/null; then
+          llvm-profdata merge -output=default.profdata default_*.profraw
+        fi
+        
+        make clean
+        make -j$(nproc) CXXOPTS="-O2 -g3 -fprofile-use" LDOPTS="-fprofile-use" simplecpp
+        VALGRIND_TOOL=callgrind SIMPLECPP_PATH=simplecpp-1.5.1 ./selfcheck.sh >callgrind_pgo.log || (cat callgrind_pgo.log && false)
+        cat callgrind_pgo.log
+        # PGO - end
+        
+        for f in callgrind.out.*;
+        do
+          callgrind_annotate --auto=no $f > $f.annotated.log
+          head -50 $f.annotated.log
+        done
+        rm -rf simplecpp-1.5.1
+
+    - uses: actions/upload-artifact@v4
+      if: matrix.os == 'ubuntu-24.04'
+      with:
+        name: Callgrind Output - ${{ matrix.compiler }}
+        path: |
+          ./callgrind.*
diff --git a/.github/workflows/CI-windows.yml b/.github/workflows/CI-windows.yml
index 1f78876d..521bc24c 100644
--- a/.github/workflows/CI-windows.yml
+++ b/.github/workflows/CI-windows.yml
@@ -6,6 +6,9 @@ name: CI-windows
 
 on: [push,pull_request]
 
+permissions:
+  contents: read
+
 defaults:
   run:
     shell: cmd
@@ -15,27 +18,34 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [windows-2019, windows-2022]
+        os: [windows-2022, windows-2025, windows-11-arm]
         config: [Release, Debug]
       fail-fast: false
 
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Setup msbuild.exe
         uses: microsoft/setup-msbuild@v2
-        
-      - name: Run cmake
-        if: matrix.os == 'windows-2019'
+
+      - name: Set up Python 3.13
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.13'
+          check-latest: true
+
+      - name: Install missing Python packages
         run: |
-          cmake -G "Visual Studio 16 2019" -A x64 . || exit /b !errorlevel!
+          python -m pip install pip --upgrade || exit /b !errorlevel!
+          python -m pip install pytest || exit /b !errorlevel!
 
-      - name: Run cmake
-        if: matrix.os == 'windows-2022'
+      - name: Run CMake
         run: |
-          cmake -G "Visual Studio 17 2022" -A x64 . || exit /b !errorlevel!
+          cmake -G "Visual Studio 17 2022" -A x64 -Werror=dev --warn-uninitialized -DCMAKE_COMPILE_WARNING_AS_ERROR=On . || exit /b !errorlevel!
 
       - name: Build
         run: |
@@ -48,4 +58,25 @@ jobs:
       - name: Selfcheck
         run: |
           .\${{ matrix.config }}\simplecpp.exe simplecpp.cpp -e || exit /b !errorlevel!
-        
+
+      - name: integration test
+        run: |
+          set SIMPLECPP_EXE_PATH=.\${{ matrix.config }}\simplecpp.exe
+          python -m pytest integration_test.py -vv || exit /b !errorlevel!
+
+      - name: Run CMake (c++17)
+        run: |
+          cmake -S . -B build.cxx17 -G "Visual Studio 17 2022" -A x64 -Werror=dev --warn-uninitialized -DCMAKE_CXX_STANDARD=17 -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+
+      - name: Build (c++17)
+        run: |
+          msbuild -m build.cxx17\simplecpp.sln /p:Configuration=${{ matrix.config }} /p:Platform=x64 || exit /b !errorlevel!
+
+      - name: Run CMake (c++20)
+        run: |
+          cmake -S . -B build.cxx20 -G "Visual Studio 17 2022" -A x64 -Werror=dev --warn-uninitialized -DCMAKE_CXX_STANDARD=20 -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+
+      - name: Build (c++20)
+        run: |
+          msbuild -m build.cxx20\simplecpp.sln /p:Configuration=${{ matrix.config }} /p:Platform=x64 || exit /b !errorlevel!
+    
diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml
index 22602075..9109be9e 100644
--- a/.github/workflows/clang-tidy.yml
+++ b/.github/workflows/clang-tidy.yml
@@ -4,13 +4,25 @@ name: clang-tidy
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
 jobs:
   build:
 
     runs-on: ubuntu-24.04
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      # the man-db trigger causes package installations to stall for several minutes at times. so just drop the package.
+      # see https://github.com/actions/runner/issues/4030
+      - name: Remove man-db package
+        run: |
+          sudo apt-get update
+          sudo apt-get remove man-db
 
       - name: Install missing software
         run: |
@@ -21,19 +33,19 @@ jobs:
         run: |
           wget https://apt.llvm.org/llvm.sh
           chmod +x llvm.sh
-          sudo ./llvm.sh 19
-          sudo apt-get install clang-tidy-19
+          sudo ./llvm.sh 21
+          sudo apt-get install clang-tidy-21
 
       - name: Verify clang-tidy configuration
         run: |
-          clang-tidy-19 --verify-config
+          clang-tidy-21 --verify-config
 
       - name: Prepare CMake
         run: |
-          cmake -S . -B cmake.output -G "Unix Makefiles" -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DDISABLE_CPP03_SYNTAX_CHECK=ON
+          cmake -S . -B cmake.output -Werror=dev --warn-uninitialized -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
         env:
-          CXX: clang-19
+          CXX: clang-21
 
       - name: Clang-Tidy
         run: |
-          run-clang-tidy-19 -q -j $(nproc) -p=cmake.output
+          run-clang-tidy-21 -q -j $(nproc) -p=cmake.output
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
new file mode 100644
index 00000000..e9f1361d
--- /dev/null
+++ b/.github/workflows/format.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: format
+
+on:
+  push:
+    branches:
+      - 'master'
+      - 'releases/**'
+      - '1.*'
+    tags:
+      - '1.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  format:
+
+    runs-on: ubuntu-22.04
+
+    defaults:
+      run:
+        shell: bash -euo pipefail {0}
+
+    env:
+      UNCRUSTIFY_INSTALL_DIR: ${{ github.workspace }}/runformat-uncrustify
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Determine uncrustify version
+        id: get-uncrustify-version
+        run: |
+          version="$(./runformat --expected-uncrustify-version)"
+          echo "Expected uncrustify version: $version"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - name: Set UNCRUSTIFY_VERSION env variable
+        run: |
+          version=$(./runformat --expected-uncrustify-version)
+          echo "version [$version]"
+          echo "UNCRUSTIFY_VERSION=${version}" >> "$GITHUB_ENV"
+
+      - name: Cache uncrustify
+        uses: actions/cache@v4
+        id: cache-uncrustify
+        with:
+          path: ${{ env.UNCRUSTIFY_INSTALL_DIR }}
+          key: ${{ runner.os }}-uncrustify-${{ steps.get-uncrustify-version.outputs.version }}
+
+      - name: Install uncrustify
+        if: steps.cache-uncrustify.outputs.cache-hit != 'true'
+        run: |
+          ./runformat --install --install-dir "${UNCRUSTIFY_INSTALL_DIR}"
+
+      - name: Uncrustify check
+        run: |
+          ./runformat
diff --git a/.gitignore b/.gitignore
index 183545f1..34d9c55d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,7 +28,11 @@
 *.app
 simplecpp
 testrunner
+/.runformat-uncrustify
 
 # CLion
 /.idea
 /cmake-build-*
+
+# python
+__pycache__/
diff --git a/.uncrustify.cfg b/.uncrustify.cfg
new file mode 100644
index 00000000..81722ff7
--- /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/CMakeLists.txt b/CMakeLists.txt
index 88c46b9e..0a90efae 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,8 @@
-cmake_minimum_required (VERSION 3.5)
+cmake_minimum_required (VERSION 3.10)
 project (simplecpp LANGUAGES CXX)
 
-option(DISABLE_CPP03_SYNTAX_CHECK "Disable the C++03 syntax check." OFF)
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include(CheckCXXCompilerFlag)
 
@@ -18,25 +19,69 @@ function(add_compile_options_safe FLAG)
     endif()
 endfunction()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-    add_compile_options(-Wall -Wextra -pedantic -Wcast-qual -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wredundant-decls -Wshadow -Wundef -Wold-style-cast -Wno-multichar)
-elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_compile_options(-pedantic)
+
+    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(-Wpacked)                   #
+    add_compile_options(-Wredundant-decls)          # if anything is declared more than once in the same scope
+    add_compile_options(-Wundef)
+    add_compile_options(-Woverloaded-virtual)       # when a function declaration hides virtual functions from a base class
+
+    add_compile_options(-Wsuggest-attribute=noreturn)
+    if (NOT MINGW)
+        add_compile_options_safe(-Wuseless-cast)
+    endif()
+
+    # we are not interested in these
+    set_source_files_properties(test.cpp PROPERTIES COMPILE_FLAGS -Wno-multichar)
+elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+
+    add_compile_options(/W4)  # Warning Level
+
+    add_compile_options(/wd4127)  # warning C4127: conditional expression is constant
+    add_compile_options(/wd4244)  # warning C4244: 'x': conversion from 'int' to 'char', possible loss of data
+    add_compile_options(/wd4267)  # warning C4267: '...': conversion from 'size_t' to 'unsigned int', possible loss of data
+    add_compile_options(/wd4706)  # warning C4706: assignment within conditional expression
 elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     add_compile_options(-Weverything)
+
     # no need for c++98 compatibility
     add_compile_options(-Wno-c++98-compat-pedantic)
-    # these are not really fixable
-    add_compile_options(-Wno-exit-time-destructors -Wno-global-constructors -Wno-weak-vtables)
+
+    # these are not really fixable until newer standards
+    add_compile_options(-Wno-exit-time-destructors)
+    add_compile_options(-Wno-global-constructors)
+    add_compile_options(-Wno-weak-vtables)
     add_compile_options_safe(-Wno-unsafe-buffer-usage)
-    # we are not interested in these
-    add_compile_options(-Wno-multichar -Wno-four-char-constants)
-    # ignore C++11-specific warning
-    add_compile_options(-Wno-suggest-override -Wno-suggest-destructor-override)
+    add_compile_options_safe(-Wno-nrvo)
+
     # contradicts -Wcovered-switch-default
     add_compile_options(-Wno-switch-default)
+    if (MINGW)
+        add_compile_options(-Wno-reserved-macro-identifier)
+        add_compile_options(-Wno-unused-macros)
+    endif()
+
+    # these are experimental warnings which might produce false positives
+    add_compile_options_safe(-Wno-thread-safety-negative)
+    add_compile_options_safe(-Wno-thread-safety-beta)
+
     # TODO: fix these?
-    add_compile_options(-Wno-padded -Wno-sign-conversion -Wno-implicit-int-conversion -Wno-shorten-64-to-32 -Wno-shadow-field-in-constructor)
+    add_compile_options(-Wno-padded)
+    add_compile_options(-Wno-sign-conversion)
+    add_compile_options(-Wno-implicit-int-conversion)
+    add_compile_options(-Wno-shorten-64-to-32)
+    add_compile_options(-Wno-shadow-field-in-constructor)
+
+    # we are not interested in these
+    set_source_files_properties(test.cpp PROPERTIES COMPILE_FLAGS "-Wno-multichar -Wno-four-char-constants")
 
     if (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 14 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 14)
         # TODO: verify this regression still exists in clang-15
@@ -48,30 +93,21 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
         # 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 (APPLE)
+        # CMake is sometimes chosing the wrong compiler on macos-* runners
+        # see https://github.com/actions/runner/issues/4034
+        add_compile_options(-Wno-poison-system-directories)
+    endif()
 endif()
 
 add_library(simplecpp_obj OBJECT simplecpp.cpp)
 
 add_executable(simplecpp $<TARGET_OBJECTS:simplecpp_obj> main.cpp)
-set_property(TARGET simplecpp PROPERTY CXX_STANDARD 11)
-
-if (NOT DISABLE_CPP03_SYNTAX_CHECK)
-    # it is not possible to set a standard older than C++14 with Visual Studio
-    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        # we need to create a dummy library as -fsyntax-only will not produce any output files causing the build to fail
-        add_library(simplecpp-03-syntax OBJECT simplecpp.cpp)
-        target_compile_options(simplecpp-03-syntax PRIVATE -std=c++03)
-        if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-            target_compile_options(simplecpp-03-syntax PRIVATE -Wno-long-long)
-        elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-            target_compile_options(simplecpp-03-syntax PRIVATE -Wno-c++11-long-long -Wno-c++11-compat)
-        endif()
-        add_dependencies(simplecpp simplecpp-03-syntax)
-    endif()
-endif()
-
 add_executable(testrunner $<TARGET_OBJECTS:simplecpp_obj> test.cpp)
-set_property(TARGET testrunner PROPERTY CXX_STANDARD 11)
+target_compile_definitions(testrunner
+    PRIVATE
+        SIMPLECPP_TEST_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
+)
 
 enable_testing()
 add_test(NAME testrunner COMMAND testrunner)
diff --git a/Makefile b/Makefile
index db1ca257..b7b54597 100644
--- a/Makefile
+++ b/Makefile
@@ -1,23 +1,29 @@
 all:	testrunner simplecpp
 
-CXXFLAGS = -Wall -Wextra -pedantic -Wcast-qual -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wredundant-decls -Wundef -Wno-multichar -Wold-style-cast -std=c++0x -g
-LDFLAGS = -g
+CPPFLAGS ?=
+CXXFLAGS = -Wall -Wextra -pedantic -Wcast-qual -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wpacked -Wredundant-decls -Wundef -Woverloaded-virtual -std=c++11 -g $(CXXOPTS)
+LDFLAGS = -g $(LDOPTS)
 
-%.o: %.cpp	simplecpp.h
-	$(CXX) $(CXXFLAGS) -c $<
+# Define test source dir macro for compilation (preprocessor flags)
+TEST_CPPFLAGS = -DSIMPLECPP_TEST_SOURCE_DIR=\"$(CURDIR)\"
+
+# Only test.o gets the define
+test.o: CPPFLAGS += $(TEST_CPPFLAGS)
+test.o: CXXFLAGS += -Wno-multichar
 
+%.o: %.cpp	simplecpp.h
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $<
 
 testrunner:	test.o	simplecpp.o
 	$(CXX) $(LDFLAGS) simplecpp.o test.o -o testrunner
 
 test:	testrunner	simplecpp
-	# The -std=c++03 makes sure that simplecpp.cpp is C++03 conformant. We don't require a C++11 compiler
-	g++ -std=c++03 -fsyntax-only simplecpp.cpp
 	./testrunner
 	python3 run-tests.py
+	python3 -m pytest integration_test.py -vv
 
 selfcheck:	simplecpp
-	./selfcheck.sh
+	CXX=$(CXX) ./selfcheck.sh
 
 simplecpp:	main.o simplecpp.o
 	$(CXX) $(LDFLAGS) main.o simplecpp.o -o simplecpp
diff --git a/appveyor.yml b/appveyor.yml
index ea8dd1df..09aa6cbe 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -10,9 +10,10 @@ environment:
 
 build_script:
   - ECHO Building %configuration% %platform% with MSVC %VisualStudioVersion% using %PlatformToolset% PlatformToolset
-  - cmake -G "Visual Studio 14" .
+  - cmake -DCMAKE_COMPILE_WARNING_AS_ERROR=On -G "Visual Studio 14" .
   - dir
   - 'CALL "C:\Program Files (x86)\Microsoft Visual Studio %VisualStudioVersion%\VC\vcvarsall.bat" %vcvarsall_platform%'
+  - set _CL_=/WX
   - msbuild "simplecpp.sln" /consoleloggerparameters:Verbosity=minimal /target:Build /property:Configuration="%configuration%";Platform=%platform% /p:PlatformToolset=%PlatformToolset% /maxcpucount /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
 
 test_script:
diff --git a/integration_test.py b/integration_test.py
new file mode 100644
index 00000000..3ca2fd02
--- /dev/null
+++ b/integration_test.py
@@ -0,0 +1,505 @@
+## test with python -m pytest integration_test.py
+
+import os
+import pathlib
+import platform
+import pytest
+from testutils import simplecpp, format_include_path_arg, format_include
+
+def __test_relative_header_create_header(dir, with_pragma_once=True):
+    header_file = os.path.join(dir, 'test.h')
+    with open(header_file, 'wt') as f:
+        f.write(f"""
+                {"#pragma once" if with_pragma_once else ""}
+                #ifndef TEST_H_INCLUDED
+                #define TEST_H_INCLUDED
+                #else
+                #error header_was_already_included
+                #endif
+                const int dummy = 1;
+                """)
+    return header_file, "error: #error header_was_already_included"
+
+def __test_relative_header_create_source(dir, include1, include2, is_include1_sys=False, is_include2_sys=False, inv=False):
+    if inv:
+        return __test_relative_header_create_source(dir, include1=include2, include2=include1, is_include1_sys=is_include2_sys, is_include2_sys=is_include1_sys)
+    ## otherwise
+
+    src_file = os.path.join(dir, 'test.c')
+    with open(src_file, 'wt') as f:
+        f.write(f"""
+                #undef TEST_H_INCLUDED
+                #include {format_include(include1, is_include1_sys)}
+                #include {format_include(include2, is_include2_sys)}
+                """)
+    return src_file
+
+@pytest.mark.parametrize("with_pragma_once", (False, True))
+@pytest.mark.parametrize("is_sys", (False, True))
+def test_relative_header_1(record_property, tmpdir, with_pragma_once, is_sys):
+    _, double_include_error = __test_relative_header_create_header(tmpdir, with_pragma_once=with_pragma_once)
+
+    test_file = __test_relative_header_create_source(tmpdir, "test.h", "test.h", is_include1_sys=is_sys, is_include2_sys=is_sys)
+
+    args = ([format_include_path_arg(tmpdir)] if is_sys else []) + [test_file]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    if with_pragma_once:
+        assert stderr == ''
+    else:
+        assert double_include_error in stderr
+
+@pytest.mark.parametrize("with_pragma_once", (False, True))
+@pytest.mark.parametrize("inv", (False, True))
+@pytest.mark.parametrize("source_relative", (False, True))
+def test_relative_header_2(record_property, tmpdir, with_pragma_once, inv, source_relative):
+    header_file, double_include_error = __test_relative_header_create_header(tmpdir, with_pragma_once=with_pragma_once)
+
+    test_file = __test_relative_header_create_source(tmpdir, "test.h", header_file, inv=inv)
+
+    args = ["test.c" if source_relative else test_file]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+    if with_pragma_once:
+        assert stderr == ''
+        if inv or not source_relative:
+            assert f'#line 8 "{pathlib.PurePath(tmpdir).as_posix()}/test.h"' in stdout
+        else:
+            assert '#line 8 "test.h"' in stdout
+    else:
+        assert double_include_error in stderr
+
+@pytest.mark.parametrize("is_sys", (False, True))
+@pytest.mark.parametrize("inv", (False, True))
+@pytest.mark.parametrize("source_relative", (False, True))
+def test_relative_header_3(record_property, tmpdir, is_sys, inv, source_relative):
+    test_subdir = os.path.join(tmpdir, "test_subdir")
+    os.mkdir(test_subdir)
+    header_file, _ = __test_relative_header_create_header(test_subdir)
+
+    test_file = __test_relative_header_create_source(tmpdir, "test_subdir/test.h", header_file, is_include1_sys=is_sys, inv=inv)
+
+    args = ["test.c" if source_relative else test_file]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    if is_sys:
+        assert "missing header: Header not found" in stderr
+    else:
+        assert stderr == ''
+        if source_relative and not inv:
+            assert '#line 8 "test_subdir/test.h"' in stdout
+        else:
+            assert f'#line 8 "{pathlib.PurePath(test_subdir).as_posix()}/test.h"' in stdout
+
+@pytest.mark.parametrize("use_short_path", (False, True))
+@pytest.mark.parametrize("relative_include_dir", (False, True))
+@pytest.mark.parametrize("is_sys", (False, True))
+@pytest.mark.parametrize("inv", (False, True))
+@pytest.mark.parametrize("source_relative", (False, True))
+def test_relative_header_4(record_property, tmpdir, use_short_path, relative_include_dir, is_sys, inv, source_relative):
+    test_subdir = os.path.join(tmpdir, "test_subdir")
+    os.mkdir(test_subdir)
+    header_file, _ = __test_relative_header_create_header(test_subdir)
+    if use_short_path:
+        header_file = "test_subdir/test.h"
+
+    test_file = __test_relative_header_create_source(tmpdir, header_file, "test.h", is_include2_sys=is_sys, inv=inv)
+
+    args = [format_include_path_arg("test_subdir" if relative_include_dir else test_subdir), "test.c" if source_relative else test_file]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert stderr == ''
+    if (source_relative and use_short_path and not inv) or (relative_include_dir and inv):
+        assert '#line 8 "test_subdir/test.h"' in stdout
+    else:
+        assert f'#line 8 "{pathlib.PurePath(test_subdir).as_posix()}/test.h"' in stdout
+
+@pytest.mark.parametrize("with_pragma_once", (False, True))
+@pytest.mark.parametrize("relative_include_dir", (False, True))
+@pytest.mark.parametrize("is_sys", (False, True))
+@pytest.mark.parametrize("inv", (False, True))
+@pytest.mark.parametrize("source_relative", (False, True))
+def test_relative_header_5(record_property, tmpdir, with_pragma_once, relative_include_dir, is_sys, inv, source_relative): # test relative paths with ..
+    ## in this test, the subdir role is the opposite then the previous - it contains the test.c file, while the parent tmpdir contains the header file
+    header_file, double_include_error = __test_relative_header_create_header(tmpdir, with_pragma_once=with_pragma_once)
+    if is_sys:
+        header_file_second_path = "test.h"
+    else:
+        header_file_second_path = "../test.h"
+
+    test_subdir = os.path.join(tmpdir, "test_subdir")
+    os.mkdir(test_subdir)
+    test_file = __test_relative_header_create_source(test_subdir, header_file, header_file_second_path, is_include2_sys=is_sys, inv=inv)
+
+    args = ([format_include_path_arg(".." if relative_include_dir else tmpdir)] if is_sys else []) + ["test.c" if source_relative else test_file]
+
+    _, stdout, stderr = simplecpp(args, cwd=test_subdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+    if with_pragma_once:
+        assert stderr == ''
+        if (relative_include_dir if is_sys else source_relative) and inv:
+            assert '#line 8 "../test.h"' in stdout
+        else:
+            assert f'#line 8 "{pathlib.PurePath(tmpdir).as_posix()}/test.h"' in stdout
+    else:
+        assert double_include_error in stderr
+
+@pytest.mark.parametrize("with_pragma_once", (False, True))
+@pytest.mark.parametrize("relative_include_dir", (False, True))
+@pytest.mark.parametrize("is_sys", (False, True))
+@pytest.mark.parametrize("inv", (False, True))
+@pytest.mark.parametrize("source_relative", (False, True))
+def test_relative_header_6(record_property, tmpdir, with_pragma_once, relative_include_dir, is_sys, inv, source_relative): # test relative paths with .. that is resolved only by an include dir
+    ## in this test, both the header and the source file are at the same dir, but there is a dummy inclusion dir as a subdir
+    header_file, double_include_error = __test_relative_header_create_header(tmpdir, with_pragma_once=with_pragma_once)
+
+    test_subdir = os.path.join(tmpdir, "test_subdir")
+    os.mkdir(test_subdir)
+    test_file = __test_relative_header_create_source(tmpdir, header_file, "../test.h", is_include2_sys=is_sys, inv=inv)
+
+    args = [format_include_path_arg("test_subdir" if relative_include_dir else test_subdir), "test.c" if source_relative else test_file]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+    if with_pragma_once:
+        assert stderr == ''
+        if relative_include_dir and inv:
+            assert '#line 8 "test.h"' in stdout
+        else:
+            assert f'#line 8 "{pathlib.PurePath(tmpdir).as_posix()}/test.h"' in stdout
+    else:
+        assert double_include_error in stderr
+
+def test_same_name_header(record_property, tmpdir):
+    include_a = os.path.join(tmpdir, "include_a")
+    include_b = os.path.join(tmpdir, "include_b")
+
+    test_file = os.path.join(tmpdir, "test.c")
+    header_a = os.path.join(include_a, "header_a.h")
+    header_b = os.path.join(include_b, "header_b.h")
+    same_name_a = os.path.join(include_a, "same_name.h")
+    same_name_b = os.path.join(include_b, "same_name.h")
+
+    os.mkdir(include_a)
+    os.mkdir(include_b)
+
+    with open(test_file, "wt") as f:
+        f.write("""
+                #include <header_a.h>
+                #include <header_b.h>
+                TEST
+                """)
+
+    with open(header_a, "wt") as f:
+        f.write("""
+                #include "same_name.h"
+                """)
+
+    with open(header_b, "wt") as f:
+        f.write("""
+                #include "same_name.h"
+                """)
+
+    with open(same_name_a, "wt") as f:
+        f.write("""
+                #define TEST E
+                """)
+
+    with open(same_name_b, "wt") as f:
+        f.write("""
+                #define TEST OK
+                """)
+
+    args = [
+        format_include_path_arg(include_a),
+        format_include_path_arg(include_b),
+        test_file
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert "OK" in stdout
+    assert stderr == ""
+
+def test_pragma_once_matching(record_property, tmpdir):
+    test_dir = os.path.join(tmpdir, "test_dir")
+    test_subdir = os.path.join(test_dir, "test_subdir")
+
+    test_file = os.path.join(test_dir, "test.c")
+    once_header = os.path.join(test_dir, "once.h")
+
+    if platform.system() == "Windows":
+        names_to_test = [
+            '"once.h"',
+            '"Once.h"',
+            '<once.h>',
+            '<Once.h>',
+            '"../test_dir/once.h"',
+            '"../test_dir/Once.h"',
+            '"../Test_Dir/once.h"',
+            '"../Test_Dir/Once.h"',
+            '"test_subdir/../once.h"',
+            '"test_subdir/../Once.h"',
+            '"Test_Subdir/../once.h"',
+            '"Test_Subdir/../Once.h"',
+            f"\"{test_dir}/once.h\"",
+            f"\"{test_dir}/Once.h\"",
+            f"<{test_dir}/once.h>",
+            f"<{test_dir}/Once.h>",
+        ]
+    else:
+        names_to_test = [
+            '"once.h"',
+            '<once.h>',
+            '"../test_dir/once.h"',
+            '"test_subdir/../once.h"',
+            f"\"{test_dir}/once.h\"",
+            f"<{test_dir}/once.h>",
+        ]
+
+    os.mkdir(test_dir)
+    os.mkdir(test_subdir)
+
+    with open(test_file, "wt") as f:
+        for n in names_to_test:
+            f.write(f"""
+                    #include {n}
+                    """);
+
+    with open(once_header, "wt") as f:
+        f.write(f"""
+                #pragma once
+                ONCE
+                """);
+
+    args = [
+        format_include_path_arg(test_dir),
+        test_file
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert stdout.count("ONCE") == 1
+    assert stderr == ""
+
+
+def test_input_multiple(record_property, tmpdir):
+    test_file = os.path.join(tmpdir, "test.c")
+    with open(test_file, 'w'):
+        pass
+
+    test_file_1 = os.path.join(tmpdir, "test1.c")
+    with open(test_file_1, 'w'):
+        pass
+
+    args = [
+        'test.c',
+        'test1.c'
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert '' == stderr
+    assert "error: multiple filenames specified\n" == stdout
+
+
+def test_input_missing(record_property, tmpdir):
+    args = [
+        'missing.c'
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert '' == stderr
+    assert "error: could not open file 'missing.c'\n" == stdout
+
+
+def test_input_dir(record_property, tmpdir):
+    test_dir = os.path.join(tmpdir, "test")
+    os.mkdir(test_dir)
+
+    args = [
+        'test'
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert '' == stderr
+    assert "error: could not open file 'test'\n" == stdout
+
+
+def test_incpath_missing(record_property, tmpdir):
+    test_file = os.path.join(tmpdir, "test.c")
+    with open(test_file, 'w'):
+        pass
+
+    test_dir = os.path.join(tmpdir, "test")
+    os.mkdir(test_dir)
+
+    args = [
+        '-Itest',
+        '-Imissing',
+        'test.c'
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert '' == stderr
+    assert "error: could not find include path 'missing'\n" == stdout
+
+
+def test_incpath_file(record_property, tmpdir):
+    test_file = os.path.join(tmpdir, "test.c")
+    with open(test_file, 'w'):
+        pass
+
+    inc_dir = os.path.join(tmpdir, "inc")
+    os.mkdir(inc_dir)
+
+    inc_file = os.path.join(tmpdir, "inc.h")
+    with open(test_file, 'w'):
+        pass
+
+    args = [
+        '-Iinc',
+        '-Iinc.h',
+        'test.c'
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert '' == stderr
+    assert "error: could not find include path 'inc.h'\n" == stdout
+
+
+def test_incfile_missing(record_property, tmpdir):
+    test_file = os.path.join(tmpdir, "test.c")
+    with open(test_file, 'w'):
+        pass
+
+    inc_file = os.path.join(tmpdir, "inc.h")
+    with open(inc_file, 'w'):
+        pass
+
+    args = [
+        '-include=inc.h',
+        '-include=missing.h',
+        'test.c'
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert '' == stderr
+    assert "error: could not open include 'missing.h'\n" == stdout
+
+
+def test_incpath_dir(record_property, tmpdir):
+    test_file = os.path.join(tmpdir, "test.c")
+    with open(test_file, 'w'):
+        pass
+
+    inc_file = os.path.join(tmpdir, "inc.h")
+    with open(inc_file, 'w'):
+        pass
+
+    inc_dir = os.path.join(tmpdir, "inc")
+    os.mkdir(inc_dir)
+
+    args = [
+        '-include=inc.h',
+        '-include=inc',
+        'test.c'
+    ]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert '' == stderr
+    assert "error: could not open include 'inc'\n" == stdout
+
+
+def test_include_header_twice(tmpdir):
+    """ Issue #581 - Failure when header is included twice with different
+    macros defined"""
+
+    header_file = tmpdir / 'test.h'
+    with open(header_file, 'wt') as f:
+        f.write(f"""
+                #if defined AAA
+                #elif defined BBB
+                # undef BBB
+                #endif
+
+                #ifdef BBB
+                # error BBB is defined
+                #endif
+                """)
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write(f"""
+                # define Y
+                # include "test.h"
+
+                # define BBB
+                # include "test.h"
+                """)
+
+    args = [test_file]
+
+    _, stdout, stderr = simplecpp(args, cwd=tmpdir)
+
+    assert stderr == ''
+
+
+def test_define(record_property, tmpdir):  # #589
+    test_file = os.path.join(tmpdir, "test.cpp")
+    with open(test_file, 'w') as f:
+        f.write(
+"""#define PREFIX_WITH_MACRO(test_name) Macro##test_name
+
+TEST_P(PREFIX_WITH_MACRO(NamingTest), n) {}
+""")
+
+    args = [
+        '-DTEST_P(A,B)=void __ ## A ## _ ## B ( )',
+        'test.cpp'
+    ]
+
+    exitcode, stdout, stderr = simplecpp(args, cwd=tmpdir)
+    record_property("stdout", stdout)
+    record_property("stderr", stderr)
+
+    assert exitcode == 0
+    assert stderr == "test.cpp:1: syntax error: failed to expand 'TEST_P', Invalid ## usage when expanding 'TEST_P': Unexpected token ')'\n"
+    assert stdout == '\n'
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
index 3f02773f..62ccc022 100644
--- a/main.cpp
+++ b/main.cpp
@@ -9,18 +9,31 @@
 #include <cstring>
 #include <fstream>
 #include <iostream>
-#include <map>
+#include <sys/stat.h>
 #include <string>
+#include <utility>
 #include <vector>
 
+static bool isDir(const std::string& path)
+{
+    struct stat file_stat;
+    if (stat(path.c_str(), &file_stat) == -1)
+        return false;
+
+    return (file_stat.st_mode & S_IFMT) == S_IFDIR;
+}
+
 int main(int argc, char **argv)
 {
     bool error = false;
     const char *filename = nullptr;
     bool use_istream = false;
+    bool fail_on_error = false;
+    bool linenrs = false;
 
     // Settings..
     simplecpp::DUI dui;
+    dui.removeComments = true;
     bool quiet = false;
     bool error_only = false;
     for (int i = 1; i < argc; i++) {
@@ -29,49 +42,80 @@ int main(int argc, char **argv)
             bool found = false;
             const char c = arg[1];
             switch (c) {
-            case 'D': // define symbol
-            {
-                const char * const value = arg[2] ? (argv[i] + 2) : argv[++i];
-                dui.defines.push_back(value);
+            case 'D': { // define symbol
                 found = true;
+                const char * const value = arg[2] ? (argv[i] + 2) : argv[++i];
+                if (!value) {
+                    std::cout << "error: option -D with no value." << std::endl;
+                    error = true;
+                    break;
+                }
+                dui.defines.emplace_back(value);
                 break;
             }
-            case 'U': // undefine symbol
-            {
+            case 'U': { // undefine symbol
+                found = true;
                 const char * const value = arg[2] ? (argv[i] + 2) : argv[++i];
+                if (!value) {
+                    std::cout << "error: option -U with no value." << std::endl;
+                    error = true;
+                    break;
+                }
                 dui.undefined.insert(value);
-                found = true;
                 break;
             }
-            case 'I': // include path
-            {
-                const char * const value = arg[2] ? (argv[i] + 2) : argv[++i];
-                dui.includePaths.push_back(value);
+            case 'I': { // include path
                 found = true;
+                const char * const value = arg[2] ? (arg + 2) : argv[++i];
+                if (!value) {
+                    std::cout << "error: option -I with no value." << std::endl;
+                    error = true;
+                    break;
+                }
+                dui.includePaths.emplace_back(value);
                 break;
             }
             case 'i':
                 if (std::strncmp(arg, "-include=",9)==0) {
-                    dui.includes.push_back(arg+9);
                     found = true;
-                }
-                else if (std::strncmp(arg, "-is",3)==0) {
-                    use_istream = true;
+                    std::string value = arg + 9;
+                    if (value.empty()) {
+                        std::cout << "error: option -include with no value." << std::endl;
+                        error = true;
+                        break;
+                    }
+                    dui.includes.emplace_back(std::move(value));
+                } else if (std::strncmp(arg, "-is",3)==0) {
                     found = true;
+                    use_istream = true;
                 }
                 break;
             case 's':
                 if (std::strncmp(arg, "-std=",5)==0) {
-                    dui.std = arg + 5;
                     found = true;
+                    std::string value = arg + 5;
+                    if (value.empty()) {
+                        std::cout << "error: option -std with no value." << std::endl;
+                        error = true;
+                        break;
+                    }
+                    dui.std = std::move(value);
                 }
                 break;
             case 'q':
-                quiet = true;
                 found = true;
+                quiet = true;
                 break;
             case 'e':
+                found = true;
                 error_only = true;
+                break;
+            case 'f':
+                found = true;
+                fail_on_error = true;
+                break;
+            case 'l':
+                linenrs = true;
                 found = true;
                 break;
             }
@@ -81,18 +125,18 @@ int main(int argc, char **argv)
             }
         } else if (filename) {
             std::cout << "error: multiple filenames specified" << std::endl;
-            std::exit(1);
+            return 1;
         } else {
             filename = arg;
         }
     }
 
     if (error)
-        std::exit(1);
+        return 1;
 
     if (quiet && error_only) {
         std::cout << "error: -e cannot be used in conjunction with -q" << std::endl;
-        std::exit(1);
+        return 1;
     }
 
     if (!filename) {
@@ -106,41 +150,64 @@ int main(int argc, char **argv)
         std::cout << "  -q              Quiet mode (no output)." << std::endl;
         std::cout << "  -is             Use std::istream interface." << std::endl;
         std::cout << "  -e              Output errors only." << std::endl;
-        std::exit(0);
+        std::cout << "  -f              Fail when errors were encountered (exitcode 1)." << std::endl;
+        std::cout << "  -l              Print lines numbers." << std::endl;
+        return 0;
     }
 
-    dui.removeComments = true;
+    // TODO: move this logic into simplecpp
+    bool inp_missing = false;
+
+    for (const std::string& inc : dui.includes) {
+        std::ifstream f(inc);
+        if (!f.is_open() || isDir(inc)) {
+            inp_missing = true;
+            std::cout << "error: could not open include '" << inc << "'" << std::endl;
+        }
+    }
+
+    for (const std::string& inc : dui.includePaths) {
+        if (!isDir(inc)) {
+            inp_missing = true;
+            std::cout << "error: could not find include path '" << inc << "'" << std::endl;
+        }
+    }
+
+    std::ifstream f(filename);
+    if (!f.is_open() || isDir(filename)) {
+        inp_missing = true;
+        std::cout << "error: could not open file '" << filename << "'" << std::endl;
+    }
+
+    if (inp_missing)
+        return 1;
 
     // Perform preprocessing
     simplecpp::OutputList outputList;
     std::vector<std::string> files;
-    simplecpp::TokenList *rawtokens;
-    if (use_istream) {
-        std::ifstream f(filename);
-        if (!f.is_open()) {
-            std::cout << "error: could not open file '" << filename << "'" << std::endl;
-            std::exit(1);
+    simplecpp::TokenList outputTokens(files);
+    {
+        simplecpp::TokenList *rawtokens;
+        if (use_istream) {
+            rawtokens = new simplecpp::TokenList(f, files,filename,&outputList);
+        } else {
+            f.close();
+            rawtokens = new simplecpp::TokenList(filename,files,&outputList);
         }
-        rawtokens = new simplecpp::TokenList(f, files,filename,&outputList);
-    }
-    else {
-        rawtokens = new simplecpp::TokenList(filename,files,&outputList);
+        rawtokens->removeComments();
+        simplecpp::FileDataCache filedata;
+        simplecpp::preprocess(outputTokens, *rawtokens, files, filedata, dui, &outputList);
+        simplecpp::cleanup(filedata);
+        delete rawtokens;
     }
-    rawtokens->removeComments();
-    simplecpp::TokenList outputTokens(files);
-    std::map<std::string, simplecpp::TokenList*> filedata;
-    simplecpp::preprocess(outputTokens, *rawtokens, files, filedata, dui, &outputList);
-    simplecpp::cleanup(filedata);
-    delete rawtokens;
-    rawtokens = nullptr;
 
     // Output
     if (!quiet) {
         if (!error_only)
-            std::cout << outputTokens.stringify() << std::endl;
+            std::cout << outputTokens.stringify(linenrs) << std::endl;
 
         for (const simplecpp::Output &output : outputList) {
-            std::cerr << output.location.file() << ':' << output.location.line << ": ";
+            std::cerr << outputTokens.file(output.location) << ':' << output.location.line << ": ";
             switch (output.type) {
             case simplecpp::Output::ERROR:
                 std::cerr << "#error: ";
@@ -177,5 +244,8 @@ int main(int argc, char **argv)
         }
     }
 
+    if (fail_on_error && !outputList.empty())
+        return 1;
+
     return 0;
 }
diff --git a/run-tests.py b/run-tests.py
index 2f28bf0f..20f59a49 100644
--- a/run-tests.py
+++ b/run-tests.py
@@ -1,22 +1,35 @@
-
 import glob
 import os
+import shutil
 import subprocess
 import sys
 
-def cleanup(out):
-  ret = ''
-  for s in out.decode('utf-8').split('\n'):
-    if len(s) > 1 and s[0] == '#':
+
+def cleanup(out: str) -> str:
+  parts = []
+  for line in out.splitlines():
+    if len(line) > 1 and line[0] == '#':
       continue
-    s = "".join(s.split())
-    ret = ret + s
-  return ret
+    parts.append("".join(line.split()))
+  return "".join(parts)
+
+
+# Check for required compilers and exit if any are missing
+CLANG_EXE = shutil.which('clang')
+if not CLANG_EXE:
+  sys.exit('Failed to run tests: clang compiler not found')
+
+GCC_EXE = shutil.which('gcc')
+if not GCC_EXE:
+  sys.exit('Failed to run tests: gcc compiler not found')
+
+SIMPLECPP_EXE = './simplecpp'
+
 
 commands = []
 
 for f in sorted(glob.glob(os.path.expanduser('testsuite/clang-preprocessor-tests/*.c*'))):
-  for line in open(f, 'rt'):
+  for line in open(f, 'rt', encoding='utf-8'):
     if line.startswith('// RUN: %clang_cc1 '):
       cmd = ''
       for arg in line[19:].split():
@@ -78,6 +91,21 @@ def cleanup(out):
          'pr57580.c',
          ]
 
+
+def run(compiler_executable: str, compiler_args: list[str]) -> tuple[int, str, str, str]:
+  """Execute a compiler command and capture its exit code, stdout, and stderr."""
+  compiler_cmd = [compiler_executable]
+  compiler_cmd.extend(compiler_args)
+
+  with subprocess.Popen(compiler_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8") as process:
+    stdout, stderr = process.communicate()
+    exit_code = process.returncode
+
+  output = cleanup(stdout)
+  error = (stderr or "").strip()
+  return (exit_code, output, stdout, error)
+
+
 numberOfSkipped = 0
 numberOfFailed = 0
 numberOfFixed = 0
@@ -89,34 +117,32 @@ def cleanup(out):
     numberOfSkipped = numberOfSkipped + 1
     continue
 
-  clang_cmd = ['clang']
-  clang_cmd.extend(cmd.split(' '))
-  p = subprocess.Popen(clang_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  comm = p.communicate()
-  clang_output = cleanup(comm[0])
+  _, clang_output_c, clang_output, _ = run(CLANG_EXE, cmd.split(' '))
 
-  gcc_cmd = ['gcc']
-  gcc_cmd.extend(cmd.split(' '))
-  p = subprocess.Popen(gcc_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  comm = p.communicate()
-  gcc_output = cleanup(comm[0])
+  _, gcc_output_c, gcc_output, _ = run(GCC_EXE, cmd.split(' '))
 
-  simplecpp_cmd = ['./simplecpp']
   # -E is not supported and we bail out on unknown options
-  simplecpp_cmd.extend(cmd.replace('-E ', '', 1).split(' '))
-  p = subprocess.Popen(simplecpp_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  comm = p.communicate()
-  simplecpp_ec = p.returncode
-  simplecpp_output = cleanup(comm[0])
-  simplecpp_err = comm[0].decode('utf-8').strip()
-
-  if simplecpp_output != clang_output and simplecpp_output != gcc_output:
+  simplecpp_ec, simplecpp_output_c, simplecpp_output, simplecpp_err = run(SIMPLECPP_EXE, cmd.replace('-E ', '', 1).split(' '))
+
+  if simplecpp_output_c != clang_output_c and simplecpp_output_c != gcc_output_c:
     filename = cmd[cmd.rfind('/')+1:]
     if filename in todo:
       print('TODO ' + cmd)
       usedTodos.append(filename)
     else:
       print('FAILED ' + cmd)
+      print('---expected (clang):')
+      print(clang_output_c)
+      print('---expected (gcc):')
+      print(gcc_output_c)
+      print('---actual:')
+      print(simplecpp_output_c)
+      print('---output (clang):')
+      print(clang_output)
+      print('---output (gcc):')
+      print(gcc_output)
+      print('---output (simplecpp):')
+      print(simplecpp_output)
       if simplecpp_ec:
           print('simplecpp failed - ' + simplecpp_err)
       numberOfFailed = numberOfFailed + 1
diff --git a/runastyle b/runastyle
deleted file mode 100755
index 64298273..00000000
--- a/runastyle
+++ /dev/null
@@ -1,23 +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="Artistic Style Version 3.0.1"
-ASTYLE="astyle"
-
-DETECTED_VERSION=`$ASTYLE --version 2>&1`
-if [[ "$DETECTED_VERSION" != ${ASTYLE_VERSION}* ]]; then
-    echo "You should use: ${ASTYLE_VERSION}";
-    echo "Detected: ${DETECTED_VERSION}"
-    exit 1;
-fi
-
-style="--style=kr --indent=spaces=4 --indent-namespaces --lineend=linux --min-conditional-indent=0"
-options="--options=none --pad-header --unpad-paren --suffix=none --convert-tabs --attach-inlines --attach-classes --attach-namespaces"
-
-$ASTYLE $style $options *.cpp
-$ASTYLE $style $options *.h
diff --git a/runastyle.bat b/runastyle.bat
deleted file mode 100644
index b8f11561..00000000
--- a/runastyle.bat
+++ /dev/null
@@ -1,26 +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 STYLE=--style=kr --indent=spaces=4 --indent-namespaces --lineend=linux --min-conditional-indent=0
-@SET OPTIONS=--pad-header --unpad-paren --suffix=none --convert-tabs --attach-inlines --attach-classes --attach-namespaces
-
-%ASTYLE% %STYLE% %OPTIONS% *.cpp
-%ASTYLE% %STYLE% %OPTIONS% *.h
\ No newline at end of file
diff --git a/runformat b/runformat
new file mode 100755
index 00000000..0dc1ad52
--- /dev/null
+++ b/runformat
@@ -0,0 +1,176 @@
+#!/bin/bash
+#
+# runformat - format this project's C++ sources with Uncrustify.
+#
+# Usage:
+#   ./runformat                                # format using the configured Uncrustify
+#   ./runformat --install                      # download, build, and use Uncrustify locally
+#   ./runformat --install --install-dir /abs/path
+#   ./runformat --expected-uncrustify-version  # print ONLY the expected Uncrustify version
+#
+# You may also set:
+#   UNCRUSTIFY=/abs/path/to/uncrustify          # use a specific binary
+#   UNCRUSTIFY_INSTALL_DIR=/abs/path            # where `--install` will install
+#
+# Requirements:
+#   - All developers must use the *exact* same Uncrustify version to avoid format churn.
+#   - Either:
+#       * Have `uncrustify` in PATH, or
+#       * Set env var UNCRUSTIFY=/absolute/path/to/uncrustify, or
+#       * Run `./runformat --install` to fetch & build the pinned version locally.
+#
+# Notes:
+#   - The local install lives under: ./.runformat-uncrustify/uncrustify-<version>-install
+#   - The config file is expected at: ./.uncrustify.cfg
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+UNCRUSTIFY_VERSION="0.80.1"
+UNCRUSTIFY_HASH="6bf662e05c4140dd4df5e45d6690cad96b4ef23c293b85813f5c725bbf1894d0"
+
+UNCRUSTIFY_WORK_DIR="${SCRIPT_DIR}/.runformat-uncrustify"
+
+# Allow external install dir override (arg or env). If not set, default under work dir.
+DEFAULT_INSTALL_DIR="${UNCRUSTIFY_WORK_DIR}/uncrustify-${UNCRUSTIFY_VERSION}-install"
+UNCRUSTIFY_INSTALL_DIR="${UNCRUSTIFY_INSTALL_DIR:-$DEFAULT_INSTALL_DIR}"
+UNCRUSTIFY_BIN="${UNCRUSTIFY_INSTALL_DIR}/bin/uncrustify"
+
+# Allow override via env; default to local pinned build path.
+UNCRUSTIFY="${UNCRUSTIFY:-$UNCRUSTIFY_BIN}"
+UNCRUSTIFY_CONFIG="${SCRIPT_DIR}/.uncrustify.cfg"
+
+err() { echo -e >&2 "ERROR: $@\n"; }
+die() { err $@; exit 1; }
+
+install_uncrustify() {
+  local root="uncrustify-${UNCRUSTIFY_VERSION}"
+  local file="${root}.tar.gz"
+  local url="https://github.com/uncrustify/uncrustify/releases/download/${root}/${file}"
+
+  mkdir -p "${UNCRUSTIFY_WORK_DIR}"
+
+  echo "Downloading ${file}..."
+  curl -fsSL -o "${UNCRUSTIFY_WORK_DIR}/${file}" "${url}"
+
+  (
+    cd "${UNCRUSTIFY_WORK_DIR}"
+
+    echo "${UNCRUSTIFY_HASH}  ${file}" > "${file}.sha256"
+    sha256sum -c "${file}.sha256"
+    rm -f "${file}.sha256"
+
+    command -v cmake >/dev/null 2>&1 || die "cmake executable not found."
+
+    echo "Extracting archive..."
+    rm -rf "${root}" "${root}-build"
+    mkdir -p "${root}"
+    tar -xzf "${file}" --strip-components=1 -C "${root}"
+
+    echo "Configuring (prefix: ${UNCRUSTIFY_INSTALL_DIR})..."
+    cmake \
+      -DCMAKE_BUILD_TYPE:STRING=Release \
+      -DCMAKE_INSTALL_PREFIX:PATH="${UNCRUSTIFY_INSTALL_DIR}" \
+      -S "${root}" -B "${root}-build"
+
+    echo "Building & installing..."
+    cmake --build "${root}-build" --config Release --target install --parallel
+  )
+
+  echo "Installed Uncrustify to: ${UNCRUSTIFY_INSTALL_DIR}"
+}
+
+print_usage_and_exit() {
+  sed -n '2,25p' "$0" | sed 's/^# \{0,1\}//'
+  exit 0
+}
+
+# Print ONLY expected Uncrustify version (no extra text).
+print_expected_uncrustify_version_and_exit() {
+  printf '%s\n' "$UNCRUSTIFY_VERSION"
+  exit 0
+}
+
+# --------------------------
+# Argument parsing
+# --------------------------
+DO_INSTALL=0
+PRINT_EXPECTED_UNCRUSTIFY_VERSION=0
+# Accept: --install, --install-dir <dir>, -h/--help
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -h|--help)
+      print_usage_and_exit
+      ;;
+    --install)
+      DO_INSTALL=1
+      shift
+      ;;
+    --install-dir)
+      [[ $# -ge 2 ]] || die "$1 requires a path argument"
+      UNCRUSTIFY_INSTALL_DIR="$(readlink -m "$2" 2>/dev/null || realpath -m "$2")"
+      UNCRUSTIFY_BIN="${UNCRUSTIFY_INSTALL_DIR}/bin/uncrustify"
+      # Only update UNCRUSTIFY default if user hasn't explicitly set it
+      if [[ "${UNCRUSTIFY:-}" != "${UNCRUSTIFY_BIN}" ]]; then
+        UNCRUSTIFY="${UNCRUSTIFY_BIN}"
+      fi
+      shift 2
+      ;;
+    --expected-uncrustify-version)
+      PRINT_EXPECTED_UNCRUSTIFY_VERSION=1
+      shift
+      ;;
+    *)
+      # ignore unrecognized positional args for now
+      shift
+      ;;
+  esac
+done
+
+if [[ "$DO_INSTALL" -eq 1 ]]; then
+  install_uncrustify
+  # Ensure we use the freshly installed binary for this run
+  UNCRUSTIFY="$UNCRUSTIFY_BIN"
+fi
+
+# If requested, print ONLY the expected Uncrustify version and exit.
+if [[ "$PRINT_EXPECTED_UNCRUSTIFY_VERSION" -eq 1 ]]; then
+  print_expected_uncrustify_version_and_exit
+fi
+
+# --------------------------
+# Validate & run
+# --------------------------
+
+# Check Uncrustify availability
+if ! command -v "$UNCRUSTIFY" >/dev/null 2>&1; then
+  err "Uncrustify executable not found: $UNCRUSTIFY"
+  die "Add it to PATH, set UNCRUSTIFY=/path/to/uncrustify, or run: $0 --install [--install-dir DIR]"
+fi
+
+# Version check
+DETECTED_VERSION="$("$UNCRUSTIFY" --version 2>&1 | grep -oE '[0-9]+(\.[0-9]+)*' | head -n1 || true)"
+echo "Detected Uncrustify: ${DETECTED_VERSION:-unknown}"
+if [[ "$DETECTED_VERSION" != "${UNCRUSTIFY_VERSION}" ]]; then
+  die "Expected Uncrustify ${UNCRUSTIFY_VERSION}. Re-run with --install (and optionally --install-dir) or set UNCRUSTIFY."
+fi
+
+# Config check
+[[ -f "$UNCRUSTIFY_CONFIG" ]] || die "Uncrustify config not found at: $UNCRUSTIFY_CONFIG"
+
+# Run formatter
+echo "Running formatter..."
+$UNCRUSTIFY -c "$UNCRUSTIFY_CONFIG" -l CPP --no-backup --replace *.cpp *.h
+
+# Show diff and fail if changes exist
+echo "Checking for formatting changes..."
+git diff --exit-code || {
+  echo
+  echo "Formatting changes were applied. Please review and commit."
+  exit 1
+}
+
+echo "Formatting is clean."
diff --git a/selfcheck.sh b/selfcheck.sh
index 3518c654..b2129cc9 100755
--- a/selfcheck.sh
+++ b/selfcheck.sh
@@ -1,6 +1,144 @@
-#!/bin/sh
+#!/bin/bash
 
-output=$(./simplecpp simplecpp.cpp -e 2>&1)
+if [ -z "$SIMPLECPP_PATH" ]; then
+  SIMPLECPP_PATH=.
+fi
+
+if [ -n "$VALGRIND_TOOL" ]; then
+  if [ "$VALGRIND_TOOL" = "memcheck" ]; then
+    VALGRIND_OPTS="--error-limit=yes --leak-check=full --num-callers=50 --show-reachable=yes --track-origins=yes --gen-suppressions=all --error-exitcode=42"
+  elif [ "$VALGRIND_TOOL" = "callgrind" ]; then
+    VALGRIND_OPTS="--tool=callgrind"
+  else
+    echo "unsupported valgrind tool '$VALGRIND_TOOL'"
+    exit 1
+  fi
+  VALGRIND_CMD="valgrind --tool=$VALGRIND_TOOL --log-fd=9 $VALGRIND_OPTS"
+  VALGRIND_REDIRECT="valgrind_$VALGRIND_TOOL.log"
+else
+  VALGRIND_CMD=
+  VALGRIND_REDIRECT="/dev/null"
+fi
+
+output=$($VALGRIND_CMD ./simplecpp "$SIMPLECPP_PATH/simplecpp.cpp" -e -f 2>&1 9> "$VALGRIND_REDIRECT")
+ec=$?
+cat "$VALGRIND_REDIRECT"
+errors=$(echo "$output" | grep -v 'Header not found: <')
+if [ $ec -ne 0 ]; then
+  # only fail if we got errors which do not refer to missing system includes
+  if [ ! -z "$errors" ]; then
+    exit $ec
+  fi
+fi
+
+if [ -z "$CXX" ]; then
+  exit 0
+fi
+
+cxx_type=$($CXX --version | head -1 | cut -d' ' -f1)
+if [ "$cxx_type" = "Ubuntu" ] || [ "$cxx_type" = "Debian" ]; then
+  cxx_type=$($CXX --version | head -1 | cut -d' ' -f2)
+fi
+
+# TODO: generate defines from compiler
+if [ "$cxx_type" = "g++" ] || [ "$cxx_type" = "g++.exe" ]; then
+  defs=
+  defs="$defs -D__GNUC__"
+  defs="$defs -D__STDC__"
+  defs="$defs -D__x86_64__"
+  defs="$defs -D__STDC_HOSTED__"
+  defs="$defs -D__CHAR_BIT__=8"
+  if [ "${MSYSTEM}" = "MINGW32" ] || [ "${MSYSTEM}" = "MINGW64" ]; then
+    defs="$defs -D_WIN32"
+  fi
+  defs="$defs -D__has_builtin(x)=(1)"
+  defs="$defs -D__has_cpp_attribute(x)=(1)"
+  defs="$defs -D__has_attribute(x)=(1)"
+  defs="$defs -Ddefined(x)=(0)"
+
+  inc=
+  while read line
+  do
+    inc="$inc -I$line"
+  done <<< "$($CXX -x c++ -v -c -S - 2>&1 < /dev/null | grep -e'^ [/A-Z]' | grep -v /cc1plus)"
+elif [ "$cxx_type" = "clang" ]; then
+  # libstdc++
+  defs=
+  defs="$defs -D__x86_64__"
+  defs="$defs -D__STDC_HOSTED__"
+  defs="$defs -D__CHAR_BIT__=8"
+  defs="$defs -D__BYTE_ORDER__=1234"
+  defs="$defs -D__SIZEOF_SIZE_T__=8"
+  if [ "${MSYSTEM}" = "MINGW32" ] || [ "${MSYSTEM}" = "MINGW64" ] || [ "${MSYSTEM}" = "CLANG64" ]; then
+    defs="$defs -D_WIN32"
+  fi
+  defs="$defs -D__has_builtin(x)=(1)"
+  defs="$defs -D__has_cpp_attribute(x)=(1)"
+  defs="$defs -D__has_feature(x)=(1)"
+  defs="$defs -D__has_include_next(x)=(1)"
+  defs="$defs -D__has_attribute(x)=(0)"
+  defs="$defs -D__building_module(x)=(0)"
+  defs="$defs -D__has_extension(x)=(1)"
+  defs="$defs -Ddefined(x)=(0)"
+
+  inc=
+  while read line
+  do
+    inc="$inc -I$line"
+  done <<< "$($CXX -x c++ -v -c -S - 2>&1 < /dev/null | grep -e'^ [/A-Z]')"
+
+  # TODO: enable
+  # libc++
+  #defs=
+  #defs="$defs -D__x86_64__"
+  #defs="$defs -D__linux__"
+  #defs="$defs -D__SIZEOF_SIZE_T__=8"
+  #defs="$defs -D__has_include_next(x)=(0)"
+  #defs="$defs -D__has_builtin(x)=(1)"
+  #defs="$defs -D__has_feature(x)=(1)"
+
+  #inc=
+  #while read line
+  #do
+  #  inc="$inc -I$line"
+  #done <<< "$($CXX -x c++ -stdlib=libc++ -v -c -S - 2>&1 < /dev/null | grep -e'^ [/A-Z]')"
+elif [ "$cxx_type" = "Apple" ]; then
+  defs=
+  defs="$defs -D__BYTE_ORDER__"
+  defs="$defs -D__APPLE__"
+  defs="$defs -D__GNUC__=15"
+  defs="$defs -D__x86_64__"
+  defs="$defs -D__SIZEOF_SIZE_T__=8"
+  defs="$defs -D__LITTLE_ENDIAN__"
+  defs="$defs -D__has_feature(x)=(0)"
+  defs="$defs -D__has_extension(x)=(1)"
+  defs="$defs -D__has_attribute(x)=(0)"
+  defs="$defs -D__has_cpp_attribute(x)=(0)"
+  defs="$defs -D__has_include_next(x)=(0)"
+  defs="$defs -D__has_builtin(x)=(1)"
+  defs="$defs -D__is_target_os(x)=(0)"
+  defs="$defs -D__is_target_arch(x)=(0)"
+  defs="$defs -D__is_target_vendor(x)=(0)"
+  defs="$defs -D__is_target_environment(x)=(0)"
+  defs="$defs -D__is_target_variant_os(x)=(0)"
+  defs="$defs -D__is_target_variant_environment(x)=(0)"
+
+  inc=
+  while read line
+  do
+    inc="$inc -I$line"
+    # TODO: pass the framework path as such when possible
+  done <<< "$($CXX -x c++ -v -c -S - 2>&1 < /dev/null | grep -e'^ [/A-Z]' | sed 's/ (framework directory)//g')"
+  echo $inc
+else
+  echo "unknown compiler '$cxx_type'"
+  exit 1
+fi
+
+# run with -std=gnuc++* so __has_include(...) is available
+$VALGRIND_CMD ./simplecpp "$SIMPLECPP_PATH/simplecpp.cpp" -e -f -std=gnu++11 $defs $inc 9> "$VALGRIND_REDIRECT"
 ec=$?
-echo "$output" | grep -v 'Header not found: <'
-exit $ec
\ No newline at end of file
+cat "$VALGRIND_REDIRECT"
+if [ $ec -ne 0 ]; then
+  exit $ec
+fi
diff --git a/simplecpp.cpp b/simplecpp.cpp
old mode 100755
new mode 100644
index 67e59abb..1d14a06c
--- a/simplecpp.cpp
+++ b/simplecpp.cpp
@@ -3,23 +3,36 @@
  * 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 <ctime>
-#include <exception>
 #include <fstream>
 #include <iostream>
 #include <istream>
@@ -31,30 +44,17 @@
 #include <stack>
 #include <stdexcept>
 #include <string>
-#if __cplusplus >= 201103L
 #ifdef SIMPLECPP_WINDOWS
-#include <mutex>
+#  include <mutex>
 #endif
 #include <unordered_map>
-#endif
 #include <utility>
 #include <vector>
 
-#ifdef SIMPLECPP_WINDOWS
-#include <windows.h>
-#undef ERROR
-#endif
-
-#if __cplusplus >= 201103L
-#define OVERRIDE override
-#define EXPLICIT explicit
+#ifdef _WIN32
+#  include <direct.h>
 #else
-#define OVERRIDE
-#define EXPLICIT
-#endif
-
-#if (__cplusplus < 201103L) && !defined(__APPLE__)
-#define nullptr NULL
+#  include <sys/stat.h>
 #endif
 
 static bool isHex(const std::string &s)
@@ -110,6 +110,15 @@ template<class T> static std::string toString(T 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;
@@ -172,8 +181,6 @@ static std::string replaceAll(std::string s, const std::string& from, const std:
     return s;
 }
 
-const std::string simplecpp::Location::emptyFileName;
-
 void simplecpp::Location::adjust(const std::string &str)
 {
     if (strpbrk(str.c_str(), "\r\n") == nullptr) {
@@ -235,21 +242,20 @@ void simplecpp::Token::printOut() const
 // cppcheck-suppress noConstructor - we call init() in the inherited to initialize the private members
 class simplecpp::TokenList::Stream {
 public:
-    virtual ~Stream() {}
+    virtual ~Stream() = default;
 
     virtual int get() = 0;
     virtual int peek() = 0;
     virtual void unget() = 0;
     virtual bool good() = 0;
 
-    unsigned char readChar()
-    {
-        unsigned char ch = static_cast<unsigned char>(get());
+    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 unsigned char ch2 = static_cast<unsigned char>(get());
+            const auto ch2 = static_cast<unsigned char>(get());
             const int ch16 = makeUtf16Char(ch, ch2);
             ch = static_cast<unsigned char>(((ch16 >= 0x80) ? 0xff : ch16));
         }
@@ -271,15 +277,14 @@ class simplecpp::TokenList::Stream {
         return ch;
     }
 
-    unsigned char peekChar()
-    {
-        unsigned char ch = static_cast<unsigned char>(peek());
+    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 unsigned char ch2 = static_cast<unsigned char>(peek());
+            const auto ch2 = static_cast<unsigned char>(peek());
             unget();
             const int ch16 = makeUtf16Char(ch, ch2);
             ch = static_cast<unsigned char>(((ch16 >= 0x80) ? 0xff : ch16));
@@ -292,8 +297,7 @@ class simplecpp::TokenList::Stream {
         return ch;
     }
 
-    void ungetChar()
-    {
+    void ungetChar() {
         unget();
         if (isUtf16)
             unget();
@@ -308,13 +312,11 @@ class simplecpp::TokenList::Stream {
     }
 
 private:
-    inline int makeUtf16Char(const unsigned char ch, const unsigned char ch2) const
-    {
+    inline int makeUtf16Char(const unsigned char ch, const unsigned char ch2) const {
         return (bom == 0xfeff) ? (ch<<8 | ch2) : (ch2<<8 | ch);
     }
 
-    unsigned short getAndSkipBOM()
-    {
+    unsigned short getAndSkipBOM() {
         const int ch1 = peek();
 
         // The UTF-16 BOM is 0xfffe or 0xfeff.
@@ -352,23 +354,22 @@ class simplecpp::TokenList::Stream {
 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)
-    {
+    explicit StdIStream(std::istream &istr)
+        : istr(istr) {
         assert(istr.good());
         init();
     }
 
-    virtual int get() OVERRIDE {
+    int get() override {
         return istr.get();
     }
-    virtual int peek() OVERRIDE {
+    int peek() override {
         return istr.peek();
     }
-    virtual void unget() OVERRIDE {
+    void unget() override {
         istr.unget();
     }
-    virtual bool good() OVERRIDE {
+    bool good() override {
         return istr.good();
     }
 
@@ -382,70 +383,72 @@ class StdCharBufStream : public simplecpp::TokenList::Stream {
     StdCharBufStream(const unsigned char* str, std::size_t size)
         : str(str)
         , size(size)
-        , pos(0)
-        , lastStatus(0)
     {
         init();
     }
 
-    virtual int get() OVERRIDE {
+    int get() override {
         if (pos >= size)
             return lastStatus = EOF;
         return str[pos++];
     }
-    virtual int peek() OVERRIDE {
+    int peek() override {
         if (pos >= size)
             return lastStatus = EOF;
         return str[pos];
     }
-    virtual void unget() OVERRIDE {
+    void unget() override {
         --pos;
     }
-    virtual bool good() OVERRIDE {
+    bool good() override {
         return lastStatus != EOF;
     }
 
 private:
     const unsigned char *str;
     const std::size_t size;
-    std::size_t pos;
-    int lastStatus;
+    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)
+    explicit FileStream(const std::string &filename, std::vector<std::string> &files)
         : file(fopen(filename.c_str(), "rb"))
-        , lastCh(0)
-        , lastStatus(0)
     {
         if (!file) {
-            files.push_back(filename);
-            throw simplecpp::Output(files, simplecpp::Output::FILE_NOT_FOUND, "File is missing: " + filename);
+            files.emplace_back(filename);
+            throw simplecpp::Output(simplecpp::Output::FILE_NOT_FOUND, {}, "File is missing: " + filename);
         }
         init();
     }
 
-    ~FileStream() OVERRIDE {
+    FileStream(const FileStream&) = delete;
+    FileStream &operator=(const FileStream&) = delete;
+
+    ~FileStream() override {
         fclose(file);
         file = nullptr;
     }
 
-    virtual int get() OVERRIDE {
+    int get() override {
         lastStatus = lastCh = fgetc(file);
         return lastCh;
     }
-    virtual int peek() OVERRIDE{
+    int peek() override {
         // keep lastCh intact
         const int ch = fgetc(file);
         unget_internal(ch);
         return ch;
     }
-    virtual void unget() OVERRIDE {
+    void unget() override {
         unget_internal(lastCh);
     }
-    virtual bool good() OVERRIDE {
+    bool good() override {
         return lastStatus != EOF;
     }
 
@@ -455,17 +458,13 @@ class FileStream : public simplecpp::TokenList::Stream {
             // TODO: use ungetc() as well
             // UTF-16 has subsequent unget() calls
             fseek(file, -1, SEEK_CUR);
-        }
-        else
+        } else
             ungetc(ch, file);
     }
 
-    FileStream(const FileStream&);
-    FileStream &operator=(const FileStream&);
-
     FILE *file;
-    int lastCh;
-    int lastStatus;
+    int lastCh{};
+    int lastStatus{};
 };
 
 simplecpp::TokenList::TokenList(std::vector<std::string> &filenames) : frontToken(nullptr), backToken(nullptr), files(filenames) {}
@@ -477,31 +476,21 @@ simplecpp::TokenList::TokenList(std::istream &istr, std::vector<std::string> &fi
     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)
+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)
 {
     StdCharBufStream stream(data, size);
     readfile(stream,filename,outputList);
 }
 
-simplecpp::TokenList::TokenList(const char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList)
-        : frontToken(nullptr), backToken(nullptr), files(filenames)
-{
-    StdCharBufStream stream(reinterpret_cast<const unsigned char*>(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)
+    : frontToken(nullptr), backToken(nullptr), files(filenames)
 {
-    try
-    {
+    try {
         FileStream stream(filename, filenames);
         readfile(stream,filename,outputList);
-    }
-    catch(const simplecpp::Output & e) // TODO handle extra type of errors
-    {
-        outputList->push_back(e);
+    } catch (const simplecpp::Output & e) {
+        outputList->emplace_back(e);
     }
 }
 
@@ -510,12 +499,10 @@ simplecpp::TokenList::TokenList(const TokenList &other) : frontToken(nullptr), b
     *this = other;
 }
 
-#if __cplusplus >= 201103L
 simplecpp::TokenList::TokenList(TokenList &&other) : frontToken(nullptr), backToken(nullptr), files(other.files)
 {
     *this = std::move(other);
 }
-#endif
 
 simplecpp::TokenList::~TokenList()
 {
@@ -534,7 +521,6 @@ simplecpp::TokenList &simplecpp::TokenList::operator=(const TokenList &other)
     return *this;
 }
 
-#if __cplusplus >= 201103L
 simplecpp::TokenList &simplecpp::TokenList::operator=(TokenList &&other)
 {
     if (this != &other) {
@@ -548,7 +534,6 @@ simplecpp::TokenList &simplecpp::TokenList::operator=(TokenList &&other)
     }
     return *this;
 }
-#endif
 
 void simplecpp::TokenList::clear()
 {
@@ -571,24 +556,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))
@@ -621,15 +616,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)
@@ -638,16 +634,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());
@@ -665,10 +661,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
 
     const Token *oldLastToken = nullptr;
 
-    Location location(files);
-    location.fileIndex = fileIndex(filename);
-    location.line = 1U;
-    location.col  = 1U;
+    Location location(fileIndex(filename), 1, 1);
     while (stream.good()) {
         unsigned char ch = stream.readChar();
         if (!stream.good())
@@ -676,13 +669,12 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
 
         if (ch >= 0x80) {
             if (outputList) {
-                simplecpp::Output err(files);
-                err.type = simplecpp::Output::UNHANDLED_CHAR_ERROR;
-                err.location = location;
-                std::ostringstream s;
-                s << static_cast<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;
@@ -691,7 +683,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
         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 {
@@ -703,33 +695,56 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
 
             if (oldLastToken != cback()) {
                 oldLastToken = cback();
-                if (!isLastLinePreprocessor())
+                const Token * const llTok = isLastLinePreprocessor();
+                if (!llTok)
                     continue;
-                const std::string lastline(lastLine());
-                if (lastline == "# file %str%") {
-                    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;
-                } else if (lastline == "# line %num%") {
-                    const Token *numtok = cback();
-                    while (numtok->comment)
-                        numtok = numtok->previous;
-                    lineDirective(location.fileIndex, std::atol(numtok->str().c_str()), &location);
-                } else if (lastline == "# %num% %str%" || lastline == "# line %num% %str%") {
-                    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);
+                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();
                 }
@@ -746,8 +761,8 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
         TokenString currentToken;
 
         if (cback() && cback()->location.line == location.line && cback()->previous && cback()->previous->op == '#') {
-            const Token* const llTok = lastLineTok();
-            if (llTok && llTok->op == '#' && llTok->next && (llTok->next->str() == "error" || llTok->next->str() == "warning")) {
+            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;
@@ -763,7 +778,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
 
         // number or name
         if (isNameChar(ch)) {
-            const bool num = std::isdigit(ch);
+            const bool num = !!std::isdigit(ch);
             while (stream.good() && isNameChar(ch)) {
                 currentToken += ch;
                 ch = stream.readChar();
@@ -776,17 +791,35 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
 
         // comment
         else if (ch == '/' && stream.peekChar() == '/') {
-            while (stream.good() && ch != '\r' && ch != '\n') {
+            while (stream.good() && ch != '\n') {
                 currentToken += ch;
                 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 {
+            if (ch == '\n') {
                 stream.ungetChar();
             }
         }
@@ -838,24 +871,26 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
                 }
                 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 (stream.good() && !(endsWith(currentToken, endOfRawString) && currentToken.size() > 1))
+                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;
                 }
@@ -865,7 +900,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
                 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();
 
@@ -886,11 +921,11 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
             }
 
             if (prefix.empty())
-                push_back(new Token(s, location, std::isspace(stream.peekChar()))); // 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 ) {
+            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;
@@ -916,7 +951,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
             }
         }
 
-        push_back(new Token(currentToken, location, std::isspace(stream.peekChar())));
+        push_back(new Token(currentToken, location, !!std::isspace(stream.peekChar())));
 
         if (multiline)
             location.col += currentToken.size();
@@ -947,7 +982,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 != '(')
@@ -1317,10 +1352,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;
@@ -1335,8 +1371,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);
@@ -1393,11 +1429,12 @@ std::string simplecpp::TokenList::readUntil(Stream &stream, const Location &loca
     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 "";
     }
@@ -1405,34 +1442,6 @@ std::string simplecpp::TokenList::readUntil(Stream &stream, const Location &loca
     return ret;
 }
 
-std::string simplecpp::TokenList::lastLine(int maxsize) const
-{
-    std::string ret;
-    int count = 0;
-    for (const Token *tok = cback(); ; tok = tok->previous) {
-        if (!sameline(tok, cback())) {
-            break;
-        }
-        if (tok->comment)
-            continue;
-        if (++count > maxsize)
-            return "";
-        if (!ret.empty())
-            ret += ' ';
-        // add tokens in reverse for performance reasons
-        if (tok->str()[0] == '\"')
-            ret += "%rts%"; // %str%
-        else if (tok->number)
-            ret += "%mun%"; // %num%
-        else {
-            ret += tok->str();
-            std::reverse(ret.end() - tok->str().length(), ret.end());
-        }
-    }
-    std::reverse(ret.begin(), ret.end());
-    return ret;
-}
-
 const simplecpp::Token* simplecpp::TokenList::lastLineTok(int maxsize) const
 {
     const Token* prevTok = nullptr;
@@ -1449,10 +1458,12 @@ const simplecpp::Token* simplecpp::TokenList::lastLineTok(int maxsize) const
     return prevTok;
 }
 
-bool simplecpp::TokenList::isLastLinePreprocessor(int maxsize) const
+const simplecpp::Token* simplecpp::TokenList::isLastLinePreprocessor(int maxsize) const
 {
     const Token * const prevTok = lastLineTok(maxsize);
-    return prevTok && prevTok->op == '#';
+    if (prevTok && prevTok->op == '#')
+        return prevTok;
+    return nullptr;
 }
 
 unsigned int simplecpp::TokenList::fileIndex(const std::string &filename)
@@ -1461,23 +1472,28 @@ 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;
-#if __cplusplus >= 201103L
     using MacroMap = std::unordered_map<TokenString,Macro>;
-#else
-    typedef std::map<TokenString,Macro> MacroMap;
-#endif
 
     class Macro {
     public:
-        explicit Macro(std::vector<std::string> &f) : nameTokDef(nullptr), valueToken(nullptr), endToken(nullptr), files(f), tokenListDefine(f), variadic(false), 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) {}
 
+        /**
+         * @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");
@@ -1494,6 +1510,9 @@ namespace simplecpp {
                 throw std::runtime_error("bad macro syntax");
         }
 
+        /**
+         * @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);
             StdCharBufStream stream(reinterpret_cast<const unsigned char*>(def.data()), def.size());
@@ -1503,7 +1522,17 @@ namespace simplecpp {
         }
 
         Macro(const Macro &other) : nameTokDef(nullptr), files(other.files), tokenListDefine(other.files), valueDefinedInCode_(other.valueDefinedInCode_) {
-            *this = other;
+            // 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;
         }
 
         Macro &operator=(const Macro &other) {
@@ -1532,14 +1561,20 @@ 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 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 == '(') {
@@ -1561,10 +1596,10 @@ namespace simplecpp {
                     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;
@@ -1612,11 +1647,11 @@ namespace simplecpp {
                 }
                 if (!rawtok2 || par != 1U)
                     break;
-                if (macro->second.expand(&output2, rawtok->location, rawtokens2.cfront(), macros, expandedmacros) != nullptr)
+                if (macro->second.expand(output2, rawtok->location, rawtokens2.cfront(), macros, expandedmacros) != nullptr)
                     break;
                 rawtok = rawtok2->next;
             }
-            output->takeTokens(output2);
+            output.takeTokens(output2);
             return rawtok;
         }
 
@@ -1662,28 +1697,28 @@ namespace simplecpp {
             }
 
             invalidHashHash(const Location &loc, const std::string &macroName, const std::string &message)
-                : Error(loc, format(macroName, message)) { }
+                : Error(loc, format(macroName, message)) {}
 
             static inline invalidHashHash unexpectedToken(const Location &loc, const std::string &macroName, const Token *tokenA) {
-                return invalidHashHash(loc, macroName, "Unexpected token '"+ tokenA->str()+"'");
+                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 invalidHashHash(loc, macroName, "Combining '"+ tokenA->str()+ "' and '"+ tokenB->str() + "' yields an invalid token.");
+                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 invalidHashHash(loc, macroName, "Unexpected newline");
+                return {loc, macroName, "Unexpected newline"};
             }
 
             static inline invalidHashHash universalCharacterUB(const Location &loc, const std::string &macroName, const Token* tokenA, const std::string& strAB) {
-                return invalidHashHash(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.");
+                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 *expandedFromToken=nullptr) const {
-            Token *tok = new Token(str,loc);
+            auto *tok = new Token(str,loc);
             if (replaced)
                 tok->macro = nameTokDef->str();
             if (expandedFromToken)
@@ -1694,6 +1729,11 @@ namespace simplecpp {
         bool parseDefine(const Token *nametoken) {
             nameTokDef = nametoken;
             variadic = false;
+            variadicOpt = false;
+            delete optExpandValue;
+            optExpandValue = nullptr;
+            delete optNoExpandValue;
+            optNoExpandValue = nullptr;
             if (!nameTokDef) {
                 valueToken = endToken = nullptr;
                 args.clear();
@@ -1709,12 +1749,12 @@ 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)) {
@@ -1731,8 +1771,49 @@ namespace simplecpp {
             if (!sameline(valueToken, nameTokDef))
                 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;
         }
 
@@ -1748,27 +1829,27 @@ 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 != 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);
+                    parametertokens.emplace_back(tok);
             }
             return parametertokens;
         }
 
-        const Token *appendTokens(TokenList *tokens,
+        const Token *appendTokens(TokenList &tokens,
                                   const Location &rawloc,
                                   const Token * const lpar,
                                   const MacroMap &macros,
@@ -1781,14 +1862,14 @@ namespace simplecpp {
             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, rawloc, 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, rawloc, tok, expandedmacros, parametertokens);
                 } else {
                     if (!expandArg(tokens, tok, rawloc, macros, expandedmacros, parametertokens)) {
-                        tokens->push_back(new Token(*tok));
+                        tokens.push_back(new Token(*tok));
                         if (tok->macro.empty() && (par > 0 || tok->str() != "("))
-                            tokens->back()->macro = name();
+                            tokens.back()->macro = name();
                     }
 
                     if (tok->op == '(')
@@ -1801,26 +1882,30 @@ namespace simplecpp {
                     tok = tok->next;
                 }
             }
-            for (Token *tok2 = tokens->front(); tok2; tok2 = tok2->next)
+            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 MacroMap &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;
             }
 
@@ -1832,7 +1917,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;
                 }
 
@@ -1869,11 +1954,11 @@ namespace simplecpp {
                     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++;
                             }
                         }
@@ -1881,10 +1966,25 @@ 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();
+
+            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 = valueToken; tok != endToken;) {
+            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 == '#') {
@@ -1892,20 +1992,20 @@ namespace simplecpp {
                             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);
+                            output.push_back(comma);
                             tok = expandToken(output, loc, tok->next->next->next, macros, expandedmacros, parametertokens2);
-                            if (output->back() == comma)
-                                output->deleteToken(comma);
+                            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));
+                        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)));
+                            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));
+                                output.push_back(newMacroToken(tok2->str(), loc, isReplaced(expandedmacros), tok2));
                         tok = tok->next;
                     } else {
                         tok = expandToken(output, loc, tok, macros, expandedmacros, parametertokens2);
@@ -1921,20 +2021,26 @@ namespace simplecpp {
                 }
                 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));
+                    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 == '#') {
@@ -1947,7 +2053,7 @@ namespace simplecpp {
             }
 
             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();
                 }
             }
@@ -1958,73 +2064,55 @@ namespace simplecpp {
             return functionLike() ? parametertokens2.back()->next : nameTokInst->next;
         }
 
-        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);
+        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;
             }
 
             if (!sameline(tok, tok->next)) {
-                output->takeTokens(temp);
+                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);
+                output.takeTokens(temp);
                 return tok->next;
             }
 
             const Macro &calledMacro = it->second;
             if (!calledMacro.functionLike()) {
-                output->takeTokens(temp);
+                output.takeTokens(temp);
                 return tok->next;
             }
 
             TokenList temp2(files);
             temp2.push_back(new Token(temp.cback()->str(), tok->location));
 
-            const Token * const tok2 = appendTokens(&temp2, loc, tok->next, macros, expandedmacros, parametertokens);
+            const Token * const tok2 = appendTokens(temp2, loc, tok->next, macros, expandedmacros, parametertokens);
             if (!tok2)
                 return tok->next;
-            output->takeTokens(temp);
-            output->deleteToken(output->back());
+            output.takeTokens(temp);
+            output.deleteToken(output.back());
             calledMacro.expand(output, loc, temp2.cfront(), macros, expandedmacros);
             return tok2->next;
         }
 
-        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 {
+        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));
+                output.push_back(newMacroToken(tok->str(), loc, true, tok));
                 return tok->next;
             }
 
             // Macro parameter..
             {
                 TokenList temp(files);
-                if (tok->str() == "__VA_OPT__") {
-                    if (sameline(tok, tok->next) && tok->next->str() == "(") {
-                        tok = tok->next;
-                        int paren = 1;
-                        while (sameline(tok, tok->next)) {
-                            if (tok->next->str() == "(")
-                              ++paren;
-                            else if (tok->next->str() == ")")
-                              --paren;
-                            if (paren == 0)
-                              return tok->next->next;
-                            tok = tok->next;
-                            if (parametertokens.size() > args.size() && parametertokens.front()->next->str() != ")")
-                              tok = expandToken(output, loc, tok, macros, expandedmacros, parametertokens)->previous;
-                        }
-                    }
-                    throw Error(tok->location, "Missing parenthesis for __VA_OPT__(content)");
-                }
-                if (expandArg(&temp, tok, loc, macros, expandedmacros, parametertokens)) {
-                    if (tok->str() == "__VA_ARGS__" && temp.empty() && output->cback() && output->cback()->str() == "," &&
+                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());
+                        output.deleteToken(output.back());
                     return recursiveExpandToken(output, temp, loc, tok, macros, expandedmacros, parametertokens);
                 }
             }
@@ -2038,23 +2126,30 @@ namespace simplecpp {
                 const Macro &calledMacro = it->second;
                 if (!calledMacro.functionLike()) {
                     TokenList temp(files);
-                    calledMacro.expand(&temp, loc, tok, macros, expandedmacros);
+                    calledMacro.expand(temp, loc, tok, macros, expandedmacros);
                     return recursiveExpandToken(output, temp, loc, tok, macros, expandedmacros2, parametertokens);
                 }
-                if (!sameline(tok, tok->next) || tok->next->op != '(') {
-                    output->push_back(newMacroToken(tok->str(), loc, true, tok));
+                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 * const tok2 = appendTokens(&tokens, loc, 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, tok));
+                    output.push_back(newMacroToken(tok->str(), loc, true, tok));
                     return tok->next;
                 }
                 TokenList temp(files);
-                calledMacro.expand(&temp, loc, tokens.cfront(), macros, expandedmacros);
-                return recursiveExpandToken(output, temp, loc, tok2, macros, expandedmacros2, parametertokens);
+                calledMacro.expand(temp, loc, tokens.cfront(), macros, expandedmacros);
+                return recursiveExpandToken(output, temp, loc, tok2, macros, expandedmacros, parametertokens);
             }
 
             if (tok->str() == DEFINED) {
@@ -2073,25 +2168,25 @@ namespace simplecpp {
                     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))
+                        if (expandArg(temp, defToken, parametertokens))
                             macroName = temp.cback()->str();
-                        if (expandArg(&temp, defToken->next->next->next, 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));
+                    output.push_back(newMacroToken(def ? "1" : "0", loc, true));
                     return lastToken->next;
                 }
             }
 
-            output->push_back(newMacroToken(tok->str(), loc, true, tok));
+            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;
 
@@ -2104,12 +2199,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 MacroMap &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());
@@ -2120,16 +2215,17 @@ namespace simplecpp {
             for (const Token *partok = parametertokens[argnr]->next; partok != parametertokens[argnr + 1U];) {
                 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())) {
-                    const std::set<TokenString> expandedmacros2; // temporary amnesia to allow reexpansion of currently expanding macros during argument evaluation
-                    partok = it->second.expand(output, loc, partok, macros, expandedmacros2);
+                    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;
+                    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;
+            if (tok->whitespaceahead && output.back())
+                output.back()->whitespaceahead = true;
             return true;
         }
 
@@ -2142,10 +2238,10 @@ namespace simplecpp {
          * @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::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);
             const MacroMap macros2; // temporarily bypass macro expansion
-            tok = expandToken(&tokenListHash, loc, tok->next, macros2, expandedmacros, parametertokens);
+            tok = expandToken(tokenListHash, loc, tok->next, macros2, expandedmacros, parametertokens);
             std::ostringstream ostr;
             ostr << '\"';
             for (const Token *hashtok = tokenListHash.cfront(), *next; hashtok; hashtok = next) {
@@ -2155,7 +2251,7 @@ namespace simplecpp {
                     ostr << ' ';
             }
             ostr << '\"';
-            output->push_back(newMacroToken(escapeString(ostr.str()), loc, isReplaced(expandedmacros)));
+            output.push_back(newMacroToken(escapeString(ostr.str()), loc, isReplaced(expandedmacros)));
             return tok;
         }
 
@@ -2168,10 +2264,11 @@ 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 MacroMap &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(), "Missing first argument");
             if (!sameline(tok, tok->next) || !sameline(tok, tok->next->next))
@@ -2179,10 +2276,9 @@ namespace simplecpp {
 
             const bool canBeConcatenatedWithEqual = A->isOneOf("+-*/%&|^") || A->str() == "<<" || A->str() == ">>";
             const bool canBeConcatenatedStringOrChar = isStringLiteral_(A->str()) || isCharLiteral_(A->str());
-            if (!A->name && !A->number && A->op != ',' && !A->str().empty() && !canBeConcatenatedWithEqual && !canBeConcatenatedStringOrChar)
-                throw invalidHashHash::unexpectedToken(tok->location, name(), A);
+            const bool unexpectedA = (!A->name && !A->number && !A->str().empty() && !canBeConcatenatedWithEqual && !canBeConcatenatedStringOrChar);
 
-            Token * const B = tok->next->next;
+            const Token * const B = tok->next->next;
             if (!B->name && !B->number && B->op && !B->isOneOf("#="))
                 throw invalidHashHash::unexpectedToken(tok->location, name(), B);
 
@@ -2198,31 +2294,38 @@ namespace simplecpp {
             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)) {
+                if (expandArg(tokensB, B, parametertokens)) {
                     for (Token *b = tokensB.front(); b; b = b->next)
                         b->location = loc;
                 } else {
                     tokensB.push_back(new Token(*B));
                     tokensB.back()->location = loc;
                 }
-                output->takeTokens(tokensB);
+                output.takeTokens(tokensB);
             } else {
                 std::string strAB;
 
                 const bool varargs = variadic && !args.empty() && B->str() == args[args.size()-1U];
 
-                if (expandArg(&tokensB, B, parametertokens)) {
+                if (expandArg(tokensB, B, parametertokens)) {
                     if (tokensB.empty())
                         strAB = A->str();
-                    else if (varargs && A->op == ',') {
+                    else if (varargs && A->op == ',')
                         strAB = ",";
-                    } else {
+                    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();
                 }
 
@@ -2235,35 +2338,38 @@ namespace simplecpp {
                 }
 
                 if (varargs && tokensB.empty() && tok->previous->str() == ",")
-                    output->deleteToken(A);
+                    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);
+                    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);
+                    nextTok = expandHashHash(output2, loc, nextTok, macros, expandedmacros, parametertokens);
+                    output.deleteToken(A);
+                    output.takeTokens(output2);
                 } else {
-                    output->deleteToken(A);
+                    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);
+                            const Token * const tok2 = appendTokens(tokens, loc, B->next, macros, expandedmacros, parametertokens);
                             if (tok2)
                                 nextTok = tok2->next;
                         }
                     }
-                    expandToken(output, loc, tokens.cfront(), macros, expandedmacros, parametertokens);
+                    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);
+                    output.takeTokens(tokensB);
                 }
             }
 
@@ -2272,11 +2378,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 */
@@ -2303,6 +2409,13 @@ namespace simplecpp {
         /** 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_;
     };
@@ -2311,9 +2424,9 @@ namespace simplecpp {
 namespace simplecpp {
 
 #ifdef __CYGWIN__
-    bool startsWith(const std::string &str, const std::string &s)
+    static bool startsWith(const std::string &s, const std::string &p)
     {
-        return (str.size() >= s.size() && str.compare(0, s.size(), s) == 0);
+        return (s.size() >= p.size()) && std::equal(p.begin(), p.end(), s.begin());
     }
 
     std::string convertCygwinToWindowsPath(const std::string &cygwinPath)
@@ -2346,188 +2459,27 @@ namespace simplecpp {
         return windowsPath;
     }
 #endif
-}
 
+    bool isAbsolutePath(const std::string &path)
+    {
 #ifdef SIMPLECPP_WINDOWS
-
-#if __cplusplus >= 201103L
-using MyMutex = std::mutex;
-template<class T>
-using MyLock = std::lock_guard<T>;
-#else
-class MyMutex {
-public:
-    MyMutex() {
-        InitializeCriticalSection(&m_criticalSection);
-    }
-
-    ~MyMutex() {
-        DeleteCriticalSection(&m_criticalSection);
-    }
-
-    CRITICAL_SECTION* lock() {
-        return &m_criticalSection;
-    }
-private:
-    CRITICAL_SECTION m_criticalSection;
-};
-
-template<typename T>
-class MyLock {
-public:
-    explicit MyLock(T& m)
-        : m_mutex(m) {
-        EnterCriticalSection(m_mutex.lock());
-    }
-
-    ~MyLock() {
-        LeaveCriticalSection(m_mutex.lock());
-    }
-
-private:
-    MyLock& operator=(const MyLock&);
-    MyLock(const MyLock&);
-
-    T& m_mutex;
-};
-#endif
-
-class RealFileNameMap {
-public:
-    RealFileNameMap() {}
-
-    bool getCacheEntry(const std::string& path, std::string& returnPath) {
-        MyLock<MyMutex> lock(m_mutex);
-
-        const 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) {
-        MyLock<MyMutex> lock(m_mutex);
-        m_fileMap[path] = actualPath;
-    }
-
-private:
-    std::map<std::string, std::string> m_fileMap;
-    MyMutex m_mutex;
-};
-
-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) {
-        const 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__
-        const std::string fConverted = simplecpp::convertCygwinToWindowsPath(f);
-        const 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) {
-        const 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;
-            }
-
-            const 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 {
     /**
      * perform path simplifications for . and ..
@@ -2599,22 +2551,23 @@ namespace simplecpp {
         if (unc)
             path = '/' + path;
 
-        // cppcheck-suppress duplicateExpressionTernary - platform-dependent implementation
-        return strpbrk(path.c_str(), "*?") == nullptr ? 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");
         }
@@ -2629,7 +2582,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)
@@ -2651,27 +2604,44 @@ static void simplifySizeof(simplecpp::TokenList &expr, const std::map<std::strin
     }
 }
 
-/** Evaluate __has_include(file) */
 static bool isCpp17OrLater(const simplecpp::DUI &dui)
 {
     const std::string std_ver = simplecpp::getCppStdString(dui.std);
-    return !std_ver.empty() && (std_ver >= "201703L");
+    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))
+    if (!isCpp17OrLater(dui) && !isGnu(dui))
         return;
 
     for (simplecpp::Token *tok = expr.front(); tok; tok = tok->next) {
         if (tok->str() != HAS_INCLUDE)
             continue;
-        simplecpp::Token *tok1 = tok->next;
+        const simplecpp::Token *tok1 = tok->next;
         if (!tok1) {
             throw std::runtime_error("missing __has_include argument");
         }
-        simplecpp::Token *tok2 = tok1->next;
+        const simplecpp::Token *tok2 = tok1->next;
         if (!tok2) {
             throw std::runtime_error("missing __has_include argument");
         }
@@ -2685,11 +2655,11 @@ static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI
             }
         }
 
-        const std::string &sourcefile = tok->location.file();
+        const std::string &sourcefile = expr.file(tok->location);
         const bool systemheader = (tok1 && tok1->op == '<');
         std::string header;
         if (systemheader) {
-            simplecpp::Token *tok3 = tok1->next;
+            const simplecpp::Token *tok3 = tok1->next;
             if (!tok3) {
                 throw std::runtime_error("missing __has_include closing angular bracket");
             }
@@ -2700,13 +2670,10 @@ static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI
                 }
             }
 
-            for (simplecpp::Token *headerToken = tok1->next; headerToken != tok3; headerToken = headerToken->next)
+            for (const simplecpp::Token *headerToken = tok1->next; headerToken != tok3; headerToken = headerToken->next)
                 header += headerToken->str();
-            // cppcheck-suppress selfAssignment - platform-dependent implementation
-            header = realFilename(header);
-        }
-        else {
-            header = realFilename(tok1->str().substr(1U, tok1->str().size() - 2U));
+        } else {
+            header = tok1->str().substr(1U, tok1->str().size() - 2U);
         }
         std::ifstream f;
         const std::string header2 = openHeader(f,dui,sourcefile,header,systemheader);
@@ -2718,12 +2685,14 @@ static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI
     }
 }
 
-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]);
+/** 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") {
@@ -2734,6 +2703,8 @@ 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");
         }
     }
@@ -2745,7 +2716,7 @@ static void simplifyName(simplecpp::TokenList &expr)
  * 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 if the above requirements were not possible to satisfy.
+ * @throws std::runtime_error thrown if the above requirements were not possible to satisfy.
  */
 static unsigned long long stringToULLbounded(
     const std::string& s,
@@ -2753,7 +2724,7 @@ static unsigned long long stringToULLbounded(
     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();
@@ -2765,34 +2736,6 @@ static unsigned long long stringToULLbounded(
     return value;
 }
 
-/* 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.
- */
 long long simplecpp::characterLiteralToLL(const std::string& str)
 {
     // default is wide/utf32
@@ -2986,6 +2929,9 @@ long long simplecpp::characterLiteralToLL(const std::string& str)
     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) {
@@ -3008,6 +2954,11 @@ static void simplifyComments(simplecpp::TokenList &expr)
     }
 }
 
+/**
+ * @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);
@@ -3036,166 +2987,217 @@ class NonExistingFilesCache {
     NonExistingFilesCache() {}
 
     bool contains(const std::string& path) {
-        MyLock<MyMutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return (m_pathSet.find(path) != m_pathSet.end());
     }
 
     void add(const std::string& path) {
-        MyLock<MyMutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         m_pathSet.insert(path);
     }
 
     void clear() {
-        MyLock<MyMutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         m_pathSet.clear();
     }
 
 private:
     std::set<std::string> m_pathSet;
-    MyMutex m_mutex;
+    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)
 {
-    std::string simplePath = simplecpp::simplifyPath(path);
 #ifdef SIMPLECPP_WINDOWS
-    if (nonExistingFilesCache.contains(simplePath))
+    if (nonExistingFilesCache.contains(path))
         return "";  // file is known not to exist, skip expensive file open call
 #endif
-    f.open(simplePath.c_str());
+    f.open(path.c_str());
     if (f.is_open())
-        return simplePath;
+        return path;
 #ifdef SIMPLECPP_WINDOWS
-    nonExistingFilesCache.add(simplePath);
+    nonExistingFilesCache.add(path);
 #endif
     return "";
 }
 
-static std::string getRelativeFileName(const std::string &sourcefile, const std::string &header)
+static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader)
 {
-    if (sourcefile.find_first_of("\\/") != std::string::npos)
-        return simplecpp::simplifyPath(sourcefile.substr(0, sourcefile.find_last_of("\\/") + 1U) + header);
-    return simplecpp::simplifyPath(header);
-}
+    if (simplecpp::isAbsolutePath(header))
+        return openHeaderDirect(f, simplecpp::simplifyPath(header));
 
-static std::string openHeaderRelative(std::ifstream &f, const std::string &sourcefile, const std::string &header)
-{
-    return openHeader(f, getRelativeFileName(sourcefile, header));
-}
-
-static std::string getIncludePathFileName(const std::string &includePath, const std::string &header)
-{
-    std::string path = includePath;
-    if (!path.empty() && path[path.size()-1U]!='/' && path[path.size()-1U]!='\\')
-        path += '/';
-    return path + header;
-}
+    // prefer first to search the header relatively to source file if found, when not a system header
+    if (!systemheader) {
+        std::string path = openHeaderDirect(f, simplecpp::simplifyPath(dirPath(sourcefile) + header));
+        if (!path.empty()) {
+            return path;
+        }
+    }
 
-static std::string openHeaderIncludePath(std::ifstream &f, const simplecpp::DUI &dui, const std::string &header)
-{
-    for (std::list<std::string>::const_iterator it = dui.includePaths.begin(); it != dui.includePaths.end(); ++it) {
-        std::string simplePath = openHeader(f, getIncludePathFileName(*it, header));
-        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 openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, 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 (isAbsolutePath(header))
-        return openHeader(f, header);
+    const std::string &path = name_it->first;
+    FileID fileId;
 
-    std::string ret;
+    if (!getFileId(path, fileId))
+        return {nullptr, false};
 
-    if (systemheader) {
-        ret = openHeaderIncludePath(f, dui, header);
-        return ret;
+    const auto id_it = mIdMap.find(fileId);
+    if (id_it != mIdMap.end()) {
+        name_it->second = id_it->second;
+        return {id_it->second, false};
     }
 
-    ret = openHeaderRelative(f, sourcefile, header);
-    if (ret.empty())
-        return openHeaderIncludePath(f, dui, header);
-    return ret;
+    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};
 }
 
-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::get(const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
 {
-    if (filedata.empty()) {
-        return "";
-    }
     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) {
-        const std::string relativeFilename = getRelativeFileName(sourcefile, header);
-        if (filedata.find(relativeFilename) != filedata.end())
-            return relativeFilename;
-    }
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(dirPath(sourcefile) + header), nullptr);
 
-    for (std::list<std::string>::const_iterator it = dui.includePaths.begin(); it != dui.includePaths.end(); ++it) {
-        std::string s = simplecpp::simplifyPath(getIncludePathFileName(*it, header));
-        if (filedata.find(s) != filedata.end())
-            return s;
+        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};
+        }
     }
 
-    if (systemheader && filedata.find(header) != filedata.end())
-        return header;
+    for (const auto &includePath : dui.includePaths) {
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(includePath + "/" + header), nullptr);
 
-    return "";
+        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 {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> &filenames, 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)
 {
 #ifdef SIMPLECPP_WINDOWS
     if (dui.clearIncludeCache)
         nonExistingFilesCache.clear();
 #endif
 
-    std::map<std::string, simplecpp::TokenList*> ret;
-
     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())
-            continue;
+        const auto loadResult = cache.get("", filename, dui, false, filenames, outputList);
+        const bool loaded = loadResult.second;
+        FileData *const filedata = loadResult.first;
 
-        std::ifstream fin(filename.c_str());
-        if (!fin.is_open()) {
+        if (filedata == nullptr) {
             if (outputList) {
-                simplecpp::Output err(filenames);
-                err.type = simplecpp::Output::EXPLICIT_INCLUDE_NOT_FOUND;
-                err.location = Location(filenames);
-                err.msg = "Can not open include file '" + filename + "' that is explicitly included.";
-                outputList->push_back(err);
+                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;
         }
-        fin.close();
 
-        TokenList *tokenlist = new TokenList(filename, filenames, outputList);
-        if (!tokenlist->front()) {
-            delete tokenlist;
+        if (!loaded)
+            continue;
+
+        if (!filedata->tokens.front())
             continue;
-        }
 
         if (dui.removeComments)
-            tokenlist->removeComments();
-        ret[filename] = tokenlist;
-        filelist.push_back(tokenlist->front());
+            filedata->tokens.removeComments();
+
+        filelist.emplace_back(filedata->tokens.front());
     }
 
     for (const Token *rawtok = rawtokens.cfront(); rawtok || !filelist.empty(); rawtok = rawtok ? rawtok->next : nullptr) {
@@ -3211,49 +3213,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 * const htok = rawtok->nextSkipComments();
         if (!sameline(rawtok, htok))
             continue;
 
         const bool systemheader = (htok->str()[0] == '<');
-        const std::string header(realFilename(htok->str().substr(1U, htok->str().size() - 2U)));
-        if (hasFile(ret, sourcefile, header, dui, systemheader))
+        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;
+
+        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;
-        f.close();
 
-        TokenList *tokens = new TokenList(header2, filenames, outputList);
         if (dui.removeComments)
-            tokens->removeComments();
-        ret[header2] = tokens;
-        if (tokens->front())
-            filelist.push_back(tokens->front());
+            filedata->tokens.removeComments();
+
+        filelist.emplace_back(filedata->tokens.front());
     }
 
-    return ret;
+    return cache;
 }
 
-static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token **tok1, simplecpp::MacroMap &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 * const tok = *tok1;
-    const simplecpp::MacroMap::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;
         }
@@ -3261,7 +3265,7 @@ 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;
 }
@@ -3288,11 +3292,11 @@ static std::string getDateDefine(const struct tm *timep)
 static std::string getTimeDefine(const struct tm *timep)
 {
     char buf[] = "??:??:??";
-    strftime(buf, sizeof(buf), "%T", timep);
+    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, std::map<std::string, simplecpp::TokenList *> &filedata, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage, std::list<simplecpp::IfCond> *ifCond)
+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)
@@ -3324,21 +3328,41 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     // 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);
+    const bool hasInclude = isCpp17OrLater(dui) || isGnu(dui);
     MacroMap macros;
-    for (std::list<std::string>::const_iterator it = dui.defines.begin(); it != dui.defines.end(); ++it) {
+    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, dummy);
-        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;
+        }
     }
 
+    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)));
@@ -3357,10 +3381,12 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
             const cppstd_t cpp_std = simplecpp::getCppStd(dui.std);
             if (cpp_std == CPPUnknown) {
                 if (outputList) {
-                    simplecpp::Output err(files);
-                    err.type = Output::DUI_ERROR;
-                    err.msg = "unknown standard specified: '" + dui.std + "'";
-                    outputList->push_back(err);
+                    simplecpp::Output err = {
+                        Output::DUI_ERROR,
+                        {},
+                        "unknown standard specified: '" + dui.std + "'"
+                    };
+                    outputList->emplace_back(std::move(err));
                 }
                 output.clear();
                 return;
@@ -3374,8 +3400,9 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     // 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 { True, ElseIsTrue, AlwaysFalse };
+    enum IfState : std::uint8_t { True, ElseIsTrue, AlwaysFalse };
     std::stack<int> ifstates;
+    std::stack<const Token *> iftokens;
     ifstates.push(True);
 
     std::stack<const Token *> includetokenstack;
@@ -3383,13 +3410,13 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     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());
     }
 
-    std::map<std::string, std::list<Location> > maybeUsedMacros;
+    std::map<std::string, std::list<Location>> maybeUsedMacros;
 
     for (const Token *rawtok = nullptr; rawtok || !includetokenstack.empty();) {
         if (rawtok == nullptr) {
@@ -3411,11 +3438,12 @@ 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;
@@ -3423,16 +3451,20 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
 
             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();
@@ -3454,11 +3486,23 @@ 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;
@@ -3472,7 +3516,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;
                     }
@@ -3494,11 +3538,12 @@ 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;
@@ -3507,50 +3552,40 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                 const Token * const inctok = inc2.cfront();
 
                 const bool systemheader = (inctok->str()[0] == '<');
-                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()) {
-                        f.close();
-                        TokenList * const tokens = new TokenList(header2, files, outputList);
-                        if (dui.removeComments)
-                            tokens->removeComments();
-                        filedata[header2] = tokens;
-                    }
-                }
-                if (header2.empty()) {
+                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 * const includetokens = filedata.find(header2)->second;
-                    rawtok = includetokens ? includetokens->cfront() : nullptr;
+                    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;
@@ -3561,10 +3596,10 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                     conditionIsTrue = false;
                 else if (rawtok->str() == IFDEF) {
                     conditionIsTrue = (macros.find(rawtok->next->str()) != macros.end() || (hasInclude && rawtok->next->str() == HAS_INCLUDE));
-                    maybeUsedMacros[rawtok->next->str()].push_back(rawtok->next->location);
+                    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()].push_back(rawtok->next->location);
+                    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) {
@@ -3578,7 +3613,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                             const bool par = (tok && tok->op == '(');
                             if (par)
                                 tok = tok->next;
-                            maybeUsedMacros[rawtok->next->str()].push_back(rawtok->next->location);
+                            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));
@@ -3591,11 +3626,12 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                                 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;
@@ -3610,35 +3646,35 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                                 tok = tok->next;
                             bool closingAngularBracket = false;
                             if (tok) {
-                                const std::string &sourcefile = rawtok->location.file();
+                                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();
-                                    // cppcheck-suppress selfAssignment - platform-dependent implementation
-                                    header = realFilename(header);
                                     if (tok && tok->op == '>')
                                         closingAngularBracket = true;
-                                }
-                                else {
-                                    header = realFilename(tok->str().substr(1U, tok->str().size() - 2U));
+                                } else {
+                                    header = tok->str().substr(1U, tok->str().size() - 2U);
                                     closingAngularBracket = true;
                                 }
-                                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 (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(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;
@@ -3646,10 +3682,10 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                             continue;
                         }
 
-                        maybeUsedMacros[rawtok->next->str()].push_back(rawtok->next->location);
+                        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;
                         }
@@ -3664,20 +3700,22 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                                 E += (E.empty() ? "" : " ") + tok->str();
                             const long long result = evaluate(expr, dui, sizeOfType);
                             conditionIsTrue = (result != 0);
-                            ifCond->push_back(IfCond(rawtok->location, E, result));
+                            ifCond->emplace_back(rawtok->location, E, result);
                         } else {
                             const long long result = evaluate(expr, dui, sizeOfType);
                             conditionIsTrue = (result != 0);
                         }
-                    } catch (const std::exception &e) {
+                    } 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;
@@ -3690,15 +3728,23 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                         ifstates.push(AlwaysFalse);
                     else
                         ifstates.push(conditionIsTrue ? True : ElseIsTrue);
-                } else if (ifstates.top() == True) {
-                    ifstates.top() = AlwaysFalse;
-                } else if (ifstates.top() == ElseIsTrue && conditionIsTrue) {
-                    ifstates.top() = True;
+                    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() == 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) {
                     const Token *tok = rawtok->next;
@@ -3708,9 +3754,12 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                         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());
+                pragmaOnce.insert(rawtokens.file(rawtok->location));
             }
-            rawtok = gotoNextLine(rawtok);
+            if (ifstates.top() != True && rawtok->nextcond)
+                rawtok = rawtok->nextcond->previous;
+            else
+                rawtok = gotoNextLine(rawtok);
             continue;
         }
 
@@ -3734,7 +3783,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;
         }
@@ -3761,59 +3810,62 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
             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)
 {
-    for (std::map<std::string, TokenList*>::iterator it = filedata.begin(); it != filedata.end(); ++it)
-        delete it->second;
-    filedata.clear();
+    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")
+    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")
+    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 CUnknown:
-            return "";
+    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 "";
 }
@@ -3844,30 +3896,29 @@ simplecpp::cppstd_t simplecpp::getCppStd(const std::string &std)
 
 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 Clang 17+
-            return "202400L";
-        case CPPUnknown:
-            return "";
+    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 "";
 }
@@ -3876,7 +3927,3 @@ std::string simplecpp::getCppStdString(const std::string &std)
 {
     return getCppStdString(getCppStd(std));
 }
-
-#if (__cplusplus < 201103L) && !defined(__APPLE__)
-#undef nullptr
-#endif
diff --git a/simplecpp.h b/simplecpp.h
old mode 100755
new mode 100644
index f5c69593..46a43bc4
--- a/simplecpp.h
+++ b/simplecpp.h
@@ -7,13 +7,27 @@
 #define simplecppH
 
 #include <cctype>
+#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
@@ -27,8 +41,8 @@
 #  define SIMPLECPP_LIB
 #endif
 
-#if (__cplusplus < 201103L) && !defined(__APPLE__)
-#define nullptr NULL
+#ifndef _WIN32
+#  include <sys/types.h>
 #endif
 
 #if defined(_MSC_VER)
@@ -38,33 +52,78 @@
 #  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
+#  endif
+#endif
+
 namespace simplecpp {
     /** C code standard */
-    enum cstd_t { CUnknown=-1, C89, C99, C11, C17, C23 };
+    enum cstd_t : std::int8_t { CUnknown=-1, C89, C99, C11, C17, C23, C2Y };
 
     /** C++ code standard */
-    enum cppstd_t { CPPUnknown=-1, CPP03, CPP11, CPP14, CPP17, CPP20, CPP23, CPP26 };
+    enum cppstd_t : std::int8_t { CPPUnknown=-1, CPP03, CPP11, CPP14, CPP17, CPP20, CPP23, CPP26 };
+
+    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)
 
-    typedef std::string TokenString;
     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);
@@ -81,16 +140,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{};
     };
 
     /**
@@ -100,21 +152,14 @@ namespace simplecpp {
     class SIMPLECPP_LIB Token {
     public:
         Token(const TokenString &s, const Location &loc, bool wsahead = false) :
-            whitespaceahead(wsahead), location(loc), previous(nullptr), next(nullptr), string(s) {
+            whitespaceahead(wsahead), location(loc), string(s) {
             flags();
         }
 
         Token(const Token &tok) :
-            macro(tok.macro), op(tok.op), comment(tok.comment), name(tok.name), number(tok.number), whitespaceahead(tok.whitespaceahead), location(tok.location), previous(nullptr), next(nullptr), string(tok.string), mExpandedFrom(tok.mExpandedFrom) {
-        }
+            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(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';
-        }
+        Token &operator=(const Token &tok) = delete;
 
         const TokenString& str() const {
             return string;
@@ -139,8 +184,9 @@ namespace simplecpp {
         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;
@@ -169,18 +215,22 @@ namespace simplecpp {
         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;
 
         std::set<const Macro*> mExpandedFrom;
-
-        // Not implemented - prevent assignment
-        Token &operator=(const Token &tok);
     };
 
     /** 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,
@@ -192,12 +242,12 @@ namespace simplecpp {
             FILE_NOT_FOUND,
             DUI_ERROR
         } type;
-        explicit Output(const std::vector<std::string>& files, Type type, const std::string& msg) : type(type), location(files), msg(msg) {}
+        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 {
@@ -208,20 +258,48 @@ namespace simplecpp {
         /** 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 */
-        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr);
+        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)
+        {}
+#ifdef 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(const char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr);
+        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 {
@@ -229,10 +307,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(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();
@@ -289,24 +371,33 @@ namespace simplecpp {
             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(Stream &stream, const Location &location, char start, char end, OutputList *outputList);
-        void lineDirective(unsigned int fileIndex, unsigned int line, Location *location);
+        void lineDirective(unsigned int fileIndex, unsigned int line, Location &location);
 
-        std::string lastLine(int maxsize=1000) const;
         const Token* lastLineTok(int maxsize=1000) const;
-        bool isLastLinePreprocessor(int maxsize=1000) const;
+        const Token* isLastLinePreprocessor(int maxsize=1000) const;
 
         unsigned int fileIndex(const std::string &filename);
 
@@ -317,11 +408,11 @@ 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 */
@@ -337,19 +428,157 @@ namespace simplecpp {
      * On the command line these are configured by -D, -U, -I, --include, -std
      */
     struct SIMPLECPP_LIB DUI {
-        DUI() : clearIncludeCache(false), removeComments(false) {}
+        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 */
+        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;
+    };
+
+    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 std::map<std::string, TokenList*> load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = nullptr);
+    SIMPLECPP_LIB FileDataCache load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = nullptr, FileDataCache cache = {});
 
     /**
      * Preprocess
@@ -357,18 +586,18 @@ 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 = nullptr, std::list<MacroUsage> *macroUsage = nullptr, std::list<IfCond> *ifCond = nullptr);
+    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);
@@ -389,14 +618,17 @@ namespace simplecpp {
     /** 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
 
-#if (__cplusplus < 201103L) && !defined(__APPLE__)
-#undef nullptr
-#endif
+#undef SIMPLECPP_LIB
 
 #endif
diff --git a/test.cpp b/test.cpp
index 8ae2fa25..ef7249e7 100644
--- a/test.cpp
+++ b/test.cpp
@@ -10,19 +10,24 @@
 #include <cstring>
 #include <exception>
 #include <iostream>
-#include <map>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
 
+#ifndef SIMPLECPP_TEST_SOURCE_DIR
+#error "SIMPLECPP_TEST_SOURCE_DIR is not defined."
+#endif
+
 #define STRINGIZE_(x) #x
 #define STRINGIZE(x) STRINGIZE_(x)
 
+static const std::string testSourceDir = SIMPLECPP_TEST_SOURCE_DIR;
 static int numberOfFailedAssertions = 0;
 
 #define ASSERT_EQUALS(expected, actual)  (assertEquals((expected), (actual), __LINE__))
-#define ASSERT_THROW_EQUALS(stmt, e, expected) do { try { stmt; assertThrowFailed(__LINE__); } catch (const e& ex) { assertEquals((expected), (ex.what()), __LINE__); } } while(false)
+#define ASSERT_THROW_EQUALS(stmt, e, expected) do { try { stmt; assertThrowFailed(__LINE__); } catch (const e& ex) { assertEquals((expected), (ex.what()), __LINE__); } } while (false)
 
 static std::string pprint(const std::string &in)
 {
@@ -40,7 +45,7 @@ static int assertEquals(const std::string &expected, const std::string &actual,
     if (expected != actual) {
         numberOfFailedAssertions++;
         std::cerr << "------ assertion failed ---------" << std::endl;
-        std::cerr << "line " << line << std::endl;
+        std::cerr << "line test.cpp:" << line << std::endl;
         std::cerr << "expected:" << pprint(expected) << std::endl;
         std::cerr << "actual:" << pprint(actual) << std::endl;
     }
@@ -77,7 +82,7 @@ static void testcase(const std::string &name, void (*f)(), int argc, char * cons
 static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)
 {
     std::istringstream istr(std::string(code, size));
-    return simplecpp::TokenList(istr,filenames,filename,outputList);
+    return {istr,filenames,filename,outputList};
 }
 
 static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)
@@ -100,11 +105,13 @@ static std::string readfile(const char code[], std::size_t size, simplecpp::Outp
 static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList)
 {
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens = makeTokenList(code,files);
-    tokens.removeComments();
+    if (dui.removeComments)
+        tokens.removeComments();
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, tokens, files, filedata, dui, outputList);
+    simplecpp::preprocess(tokens2, tokens, files, cache, dui, outputList);
+    simplecpp::cleanup(cache);
     return tokens2.stringify();
 }
 
@@ -249,10 +256,10 @@ static void characterLiteral()
     ASSERT_EQUALS('\u0012',     simplecpp::characterLiteralToLL("'\\u0012'"));
     ASSERT_EQUALS('\U00000012', simplecpp::characterLiteralToLL("'\\U00000012'"));
 
-    ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('b'))    << 8) | static_cast<unsigned char>('c'),    simplecpp::characterLiteralToLL("'bc'"));
+    ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('b')) << 8) | static_cast<unsigned char>('c'),    simplecpp::characterLiteralToLL("'bc'"));
     ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\x23')) << 8) | static_cast<unsigned char>('\x45'), simplecpp::characterLiteralToLL("'\\x23\\x45'"));
-    ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\11'))  << 8) | static_cast<unsigned char>('\222'), simplecpp::characterLiteralToLL("'\\11\\222'"));
-    ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\a'))   << 8) | static_cast<unsigned char>('\b'),   simplecpp::characterLiteralToLL("'\\a\\b'"));
+    ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\11')) << 8) | static_cast<unsigned char>('\222'), simplecpp::characterLiteralToLL("'\\11\\222'"));
+    ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\a')) << 8) | static_cast<unsigned char>('\b'),   simplecpp::characterLiteralToLL("'\\a\\b'"));
     if (sizeof(int) <= 4)
         ASSERT_EQUALS(-1, simplecpp::characterLiteralToLL("'\\xff\\xff\\xff\\xff'"));
     else
@@ -279,9 +286,9 @@ static void characterLiteral()
 
 #ifdef __GNUC__
     // BEGIN Implementation-specific results
-    ASSERT_EQUALS(static_cast<int>('AB'), simplecpp::characterLiteralToLL("'AB'"));
-    ASSERT_EQUALS(static_cast<int>('ABC'), simplecpp::characterLiteralToLL("'ABC'"));
-    ASSERT_EQUALS(static_cast<int>('ABCD'), simplecpp::characterLiteralToLL("'ABCD'"));
+    ASSERT_EQUALS('AB', simplecpp::characterLiteralToLL("'AB'"));
+    ASSERT_EQUALS('ABC', simplecpp::characterLiteralToLL("'ABC'"));
+    ASSERT_EQUALS('ABCD', simplecpp::characterLiteralToLL("'ABCD'"));
     ASSERT_EQUALS('\134t', simplecpp::characterLiteralToLL("'\\134t'")); // cppcheck ticket #7452
     // END Implementation-specific results
 #endif
@@ -314,6 +321,8 @@ static void characterLiteral()
     ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\343\201\202'"), std::runtime_error, "code point too large");
     ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\360\223\200\200'"), std::runtime_error, "code point too large");
 
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\U11111111"), std::runtime_error, "code point too large");
+
     ASSERT_EQUALS('\x89', simplecpp::characterLiteralToLL("'\x89'"));
     ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x89'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");
 
@@ -365,6 +374,33 @@ static void characterLiteral()
 
     ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xed\xa0\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");
     ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xed\xbf\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL(""), std::runtime_error, "expected a character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("LU"), std::runtime_error, "expected a character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL(";\n"), std::runtime_error, "expected a character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8U"), std::runtime_error, "expected a character literal");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\n\n"), std::runtime_error, "raw single quotes and newlines not allowed in character literals");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("''&"), std::runtime_error, "raw single quotes and newlines not allowed in character literals");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L'\fff"), std::runtime_error, "multiple characters only supported in narrow character literals");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\\n"), std::runtime_error, "unexpected end of character literal");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'"), std::runtime_error, "missing closing quote in character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u'"), std::runtime_error, "missing closing quote in character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L'"), std::runtime_error, "missing closing quote in character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'a"), std::runtime_error, "missing closing quote in character literal");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("''"), std::runtime_error, "empty character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L''"), std::runtime_error, "empty character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U''"), std::runtime_error, "empty character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u''"), std::runtime_error, "empty character literal");
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8''"), std::runtime_error, "empty character literal");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\555"), std::runtime_error, "numeric escape sequence too large");
+
+    ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u'Ó"), std::runtime_error, "assumed UTF-8 encoded source, but character literal ends unexpectedly");
 }
 
 static void combineOperators_floatliteral()
@@ -431,10 +467,39 @@ static void comment()
 
 static void comment_multiline()
 {
+    simplecpp::DUI dui;
+    dui.removeComments = true;
+
     const char code[] = "#define ABC {// \\\n"
                         "}\n"
                         "void f() ABC\n";
-    ASSERT_EQUALS("\n\nvoid f ( ) { }", preprocess(code));
+    ASSERT_EQUALS("\n\nvoid f ( ) {", preprocess(code, dui));
+
+    const char code1[] = "#define ABC {// \\\r\n"
+                         "}\n"
+                         "void f() ABC\n";
+    ASSERT_EQUALS("\n\nvoid f ( ) {", preprocess(code1, dui));
+
+    const char code2[] = "#define A 1// \\\r"
+                         "\r"
+                         "2\r"
+                         "A\r";
+    ASSERT_EQUALS("\n\n2\n1", preprocess(code2, dui));
+
+    const char code3[] = "void f() {// \\ \n}\n";
+    ASSERT_EQUALS("void f ( ) {", preprocess(code3, dui));
+
+    const char code4[] = "void f() {// \\\\\\\t\t\n}\n";
+    ASSERT_EQUALS("void f ( ) {", preprocess(code4, dui));
+
+    const char code5[] = "void f() {// \\\\\\a\n}\n";
+    ASSERT_EQUALS("void f ( ) {\n}", preprocess(code5, dui));
+
+    const char code6[] = "void f() {// \\\n\n\n}\n";
+    ASSERT_EQUALS("void f ( ) {\n\n\n}", preprocess(code6, dui));
+
+    // #471 ensure there is newline in comment so that line-splicing can be detected by tools
+    ASSERT_EQUALS("// abc\ndef", readfile("// abc\\\ndef"));
 }
 
 
@@ -538,9 +603,12 @@ static void define6()
 
 static void define7()
 {
+    simplecpp::DUI dui;
+    dui.removeComments = true;
+
     const char code[] = "#define A(X) X+1\n"
                         "A(1 /*23*/)";
-    ASSERT_EQUALS("\n1 + 1", preprocess(code));
+    ASSERT_EQUALS("\n1 + 1", preprocess(code, dui));
 }
 
 static void define8()   // 6.10.3.10
@@ -731,7 +799,7 @@ static void define_define_11a()
                         "#define TEST_MACRO         CONCAT(A, B, C)\n"
                         "TEST_MACRO\n";
     ASSERT_EQUALS("\n\n\n\n\n0x1", preprocess(code));
-    
+
     const char code2[] = "#define ADDER_S(a, b) a + b\n" // #374
                          "#define ADDER(x) ADDER_S(x)\n"
                          "#define ARGUMENTS 1, 2\n"
@@ -809,6 +877,57 @@ static void define_define_19() // #292
     ASSERT_EQUALS("\n\n\n1 , 2 , 3", preprocess(code));
 }
 
+static void define_define_20() // #384 arg contains comma
+{
+    const char code[] = "#define Z_IS_ENABLED1(config_macro) Z_IS_ENABLED2(_XXXX##config_macro)\n"
+                        "#define _XXXX1 _YYYY,\n"
+                        "#define Z_IS_ENABLED2(one_or_two_args) Z_IS_ENABLED3(one_or_two_args 1, 0)\n"
+                        "#define Z_IS_ENABLED3(ignore_this, val, ...) val\n"
+                        "#define IS_ENABLED(config_macro) Z_IS_ENABLED1(config_macro)\n"
+                        "#define FEATURE 1\n"
+                        "a = IS_ENABLED(FEATURE)\n";
+    ASSERT_EQUALS("\n\n\n\n\n\na = 1", preprocess(code));
+}
+
+static void define_define_21() // #397 DEBRACKET macro
+{
+    const char code1[] = "#define A(val) B val\n"
+                         "#define B(val) val\n"
+                         "A((2))\n";
+    ASSERT_EQUALS("\n\n2", preprocess(code1));
+
+    const char code2[] = "#define x (2)\n"
+                         "#define A B x\n"
+                         "#define B(val) val\n"
+                         "A\n";
+    ASSERT_EQUALS("\n\n\nB ( 2 )", preprocess(code2));
+
+    const char code3[] = "#define __GET_ARG2_DEBRACKET(ignore_this, val, ...) __DEBRACKET val\n"
+                         "#define __DEBRACKET(...) __VA_ARGS__\n"
+                         "#5 \"a.c\"\n"
+                         "__GET_ARG2_DEBRACKET(432 (33), (B))\n";
+    ASSERT_EQUALS("\n#line 5 \"a.c\"\nB", preprocess(code3));
+}
+
+static void define_define_22() // #400 inner macro not expanded after hash hash
+{
+    const char code[] = "#define FOO(a) CAT(DO, STUFF)(1,2)\n"
+                        "#define DOSTUFF(a, b)  CAT(3, 4)\n"
+                        "#define CAT(a, b) a##b\n"
+                        "FOO(1)\n";
+    ASSERT_EQUALS("\n\n\n34", preprocess(code));
+}
+
+static void define_define_23() // #403 crash (infinite recursion)
+{
+    const char code[] = "#define C_(x, y)       x ## y\n"
+                        "#define C(x, y)        C_(x, y)\n"
+                        "#define X(func)        C(Y, C(func, Z))\n"
+                        "#define die X(die)\n"
+                        "die(void);\n";
+    ASSERT_EQUALS("\n\n\n\nYdieZ ( void ) ;", preprocess(code));
+}
+
 static void define_va_args_1()
 {
     const char code[] = "#define A(fmt...) dostuff(fmt)\n"
@@ -837,18 +956,18 @@ static void define_va_args_4() // cppcheck trac #9754
     ASSERT_EQUALS("\nprintf ( 1 , 2 )", preprocess(code));
 }
 
-static void define_va_opt_1() 
+static void define_va_opt_1()
 {
     const char code[] = "#define p1(fmt, args...) printf(fmt __VA_OPT__(,) args)\n"
                         "p1(\"hello\");\n"
                         "p1(\"%s\", \"hello\");\n";
 
     ASSERT_EQUALS("\nprintf ( \"hello\" ) ;\n"
-        "printf ( \"%s\" , \"hello\" ) ;",
-        preprocess(code));
+                  "printf ( \"%s\" , \"hello\" ) ;",
+                  preprocess(code));
 }
 
-static void define_va_opt_2() 
+static void define_va_opt_2()
 {
     const char code[] = "#define err(...)\\\n"
                         "__VA_OPT__(\\\n"
@@ -870,8 +989,8 @@ static void define_va_opt_3()
 
     simplecpp::OutputList outputList;
     ASSERT_EQUALS("", preprocess(code1, &outputList));
-    ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'err', Missing parenthesis for __VA_OPT__(content)\n",
-        toString(outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing closing parenthesis for __VA_OPT__\n",
+                  toString(outputList));
 
     outputList.clear();
 
@@ -881,11 +1000,11 @@ static void define_va_opt_3()
                          "err()";
 
     ASSERT_EQUALS("", preprocess(code2, &outputList));
-    ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'err', Missing parenthesis for __VA_OPT__(content)\n",
-        toString(outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing opening parenthesis for __VA_OPT__\n",
+                  toString(outputList));
 }
 
-static void define_va_opt_4() 
+static void define_va_opt_4()
 {
     // missing parenthesis
     const char code1[] = "#define err(...) __VA_OPT__ something\n"
@@ -893,8 +1012,8 @@ static void define_va_opt_4()
 
     simplecpp::OutputList outputList;
     ASSERT_EQUALS("", preprocess(code1, &outputList));
-    ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'err', Missing parenthesis for __VA_OPT__(content)\n",
-        toString(outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing opening parenthesis for __VA_OPT__\n",
+                  toString(outputList));
 
     outputList.clear();
 
@@ -903,8 +1022,8 @@ static void define_va_opt_4()
                          "err()";
 
     ASSERT_EQUALS("", preprocess(code2, &outputList));
-    ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'err', Missing parenthesis for __VA_OPT__(content)\n",
-        toString(outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing opening parenthesis for __VA_OPT__\n",
+                  toString(outputList));
 }
 
 static void define_va_opt_5()
@@ -915,8 +1034,57 @@ static void define_va_opt_5()
 
     simplecpp::OutputList outputList;
     ASSERT_EQUALS("", preprocess(code, &outputList));
-    ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'err', Missing parenthesis for __VA_OPT__(content)\n",
-        toString(outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing opening parenthesis for __VA_OPT__\n",
+                  toString(outputList));
+}
+
+static void define_va_opt_6()
+{
+    // nested __VA_OPT__
+    const char code[] = "#define err(...) __VA_OPT__(__VA_OPT__(something))\n"
+                        "err()";
+
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("", preprocess(code, &outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': __VA_OPT__ cannot be nested\n",
+                  toString(outputList));
+}
+
+static void define_va_opt_7()
+{
+    // eof in __VA_OPT__
+    const char code1[] = "#define err(...) __VA_OPT__";
+
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("", preprocess(code1, &outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing opening parenthesis for __VA_OPT__\n",
+                  toString(outputList));
+
+    outputList.clear();
+
+    const char code2[] = "#define err(...) __VA_OPT__(";
+
+    ASSERT_EQUALS("", preprocess(code2, &outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing closing parenthesis for __VA_OPT__\n",
+                  toString(outputList));
+
+    outputList.clear();
+
+    const char code3[] = "#define err(...) __VA_OPT__(x";
+
+    ASSERT_EQUALS("", preprocess(code3, &outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing closing parenthesis for __VA_OPT__\n",
+                  toString(outputList));
+}
+
+static void define_va_opt_8()
+{
+    const char code[] = "#define f(...) #__VA_OPT__(x)\n"
+                        "const char* v1 = f();";
+
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("\nconst char * v1 = \"\" ;", preprocess(code, &outputList));
+    ASSERT_EQUALS("", toString(outputList));
 }
 
 static void define_ifdef()
@@ -936,14 +1104,14 @@ static void define_ifdef()
 static void pragma_backslash()
 {
     const char code[] = "#pragma comment (longstring, \\\n"
-                         "\"HEADER\\\n"
-                         "This is a very long string that is\\\n"
-                         "a multi-line string.\\\n"
-                         "How much more do I have to say?\\\n"
-                         "Well, be prepared, because the\\\n"
-                         "story is just beginning. This is a test\\\n"
-                         "string for demonstration purposes. \")\n";
-    
+                        "\"HEADER\\\n"
+                        "This is a very long string that is\\\n"
+                        "a multi-line string.\\\n"
+                        "How much more do I have to say?\\\n"
+                        "Well, be prepared, because the\\\n"
+                        "story is just beginning. This is a test\\\n"
+                        "string for demonstration purposes. \")\n";
+
     simplecpp::OutputList outputList;
     ASSERT_EQUALS("", preprocess(code, &outputList));
 }
@@ -985,11 +1153,11 @@ static void error4()
     // "#error x\n1"
     const char code[] = "\xFE\xFF\x00\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x31";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     const simplecpp::TokenList rawtoken = makeTokenList(code, sizeof(code),files,"test.c");
-    simplecpp::preprocess(tokens2, rawtoken, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::preprocess(tokens2, rawtoken, files, cache, simplecpp::DUI(), &outputList);
     ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));
 }
 
@@ -998,11 +1166,11 @@ static void error5()
     // "#error x\n1"
     const char code[] = "\xFF\xFE\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x78\x00\x31\x00";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code, sizeof(code),files,"test.c");
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI(), &outputList);
     ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));
 }
 
@@ -1409,6 +1577,17 @@ static void hashhash_null_stmt()
     ASSERT_EQUALS("\n\n\n\n1 ;", preprocess(code, &outputList));
 }
 
+static void hashhash_empty_va_args()
+{
+    // #395 hash hash with an empty __VA_ARGS__ in a macro
+    const char code[] =
+        "#define CAT(a, ...)        a##__VA_ARGS__\n"
+        "#define X(a, ...)          CAT(a)\n"
+        "#define LEVEL_2            (2)\n"
+        "X(LEVEL_2)\n";
+    ASSERT_EQUALS("\n\n\n( 2 )", preprocess(code));
+}
+
 static void hashhash_universal_character()
 {
     const char code[] =
@@ -1428,11 +1607,14 @@ static void has_include_1()
                         "  #endif\n"
                         "#endif";
     simplecpp::DUI dui;
-    dui.std = "c++17";
-    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
+    dui.includePaths.emplace_back(testSourceDir);
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui)); // we default to latest standard internally
     dui.std = "c++14";
     ASSERT_EQUALS("", preprocess(code, dui));
-    ASSERT_EQUALS("", preprocess(code));
+    dui.std = "c++17";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
+    dui.std = "c++20";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
 }
 
 static void has_include_2()
@@ -1445,9 +1627,15 @@ static void has_include_2()
                         "  #endif\n"
                         "#endif";
     simplecpp::DUI dui;
+    dui.removeComments = true; // TODO: remove this
+    dui.includePaths.emplace_back(testSourceDir);
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui)); // we default to latest standard internally
+    dui.std = "c++14";
+    ASSERT_EQUALS("", preprocess(code, dui));
     dui.std = "c++17";
     ASSERT_EQUALS("\n\nA", preprocess(code, dui));
-    ASSERT_EQUALS("", preprocess(code));
+    dui.std = "c++20";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
 }
 
 static void has_include_3()
@@ -1460,13 +1648,24 @@ static void has_include_3()
                         "  #endif\n"
                         "#endif";
     simplecpp::DUI dui;
-    dui.std = "c++17";
+
     // Test file not found...
+    ASSERT_EQUALS("\n\n\n\nB", preprocess(code, dui)); // we default to latest standard internally
+    dui.std = "c++14";
+    ASSERT_EQUALS("", preprocess(code, dui));
+    dui.std = "c++17";
     ASSERT_EQUALS("\n\n\n\nB", preprocess(code, dui));
+
     // Unless -I is set (preferably, we should differentiate -I and -isystem...)
-    dui.includePaths.push_back("./testsuite");
+    dui.includePaths.emplace_back(testSourceDir + "/testsuite");
+    dui.std = "";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui)); // we default to latest standard internally
+    dui.std = "c++14";
+    ASSERT_EQUALS("", preprocess(code, dui));
+    dui.std = "c++17";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
+    dui.std = "c++20";
     ASSERT_EQUALS("\n\nA", preprocess(code, dui));
-    ASSERT_EQUALS("", preprocess(code));
 }
 
 static void has_include_4()
@@ -1479,9 +1678,14 @@ static void has_include_4()
                         "  #endif\n"
                         "#endif";
     simplecpp::DUI dui;
+    dui.includePaths.emplace_back(testSourceDir); // we default to latest standard internally
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
+    dui.std = "c++14";
+    ASSERT_EQUALS("", preprocess(code, dui));
     dui.std = "c++17";
     ASSERT_EQUALS("\n\nA", preprocess(code, dui));
-    ASSERT_EQUALS("", preprocess(code));
+    dui.std = "c++20";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
 }
 
 static void has_include_5()
@@ -1494,9 +1698,74 @@ static void has_include_5()
                         "  #endif\n"
                         "#endif";
     simplecpp::DUI dui;
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui)); // we default to latest standard internally
+    dui.includePaths.emplace_back(testSourceDir);
+    dui.std = "c++14";
+    ASSERT_EQUALS("", preprocess(code, dui));
     dui.std = "c++17";
     ASSERT_EQUALS("\n\nA", preprocess(code, dui));
-    ASSERT_EQUALS("", preprocess(code));
+    dui.std = "c++20";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
+}
+
+static void has_include_6()
+{
+    const char code[] = "#if defined( __has_include)\n"
+                        "  #if !__has_include(<testsuite/unrealFileName2.abcdef>)\n"
+                        "    A\n"
+                        "  #else\n"
+                        "    B\n"
+                        "  #endif\n"
+                        "#endif";
+    simplecpp::DUI dui;
+    dui.includePaths.emplace_back(testSourceDir);
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui)); // we default to latest standard internally
+    dui.std = "c++99";
+    ASSERT_EQUALS("", preprocess(code, dui));
+    dui.std = "gnu99";
+    ASSERT_EQUALS("\n\nA", preprocess(code, dui));
+}
+
+static void strict_ansi_1()
+{
+    const char code[] = "#if __STRICT_ANSI__\n"
+                        " A\n"
+                        "#endif";
+    simplecpp::DUI dui;
+    dui.std = "gnu99";
+    ASSERT_EQUALS("", preprocess(code, dui));
+}
+
+static void strict_ansi_2()
+{
+    const char code[] = "#if __STRICT_ANSI__\n"
+                        " A\n"
+                        "#endif";
+    simplecpp::DUI dui;
+    dui.std = "c99";
+    ASSERT_EQUALS("\nA", preprocess(code, dui));
+}
+
+static void strict_ansi_3()
+{
+    const char code[] = "#if __STRICT_ANSI__\n"
+                        " A\n"
+                        "#endif";
+    simplecpp::DUI dui;
+    dui.std = "c99";
+    dui.undefined.insert("__STRICT_ANSI__");
+    ASSERT_EQUALS("", preprocess(code, dui));
+}
+
+static void strict_ansi_4()
+{
+    const char code[] = "#if __STRICT_ANSI__\n"
+                        " A\n"
+                        "#endif";
+    simplecpp::DUI dui;
+    dui.std = "gnu99";
+    dui.defines.emplace_back("__STRICT_ANSI__");
+    ASSERT_EQUALS("\nA", preprocess(code, dui));
 }
 
 static void ifdef1()
@@ -1542,7 +1811,7 @@ static void ifA()
     ASSERT_EQUALS("", preprocess(code));
 
     simplecpp::DUI dui;
-    dui.defines.push_back("A=1");
+    dui.defines.emplace_back("A=1");
     ASSERT_EQUALS("\nX", preprocess(code, dui));
 }
 
@@ -1561,7 +1830,7 @@ static void ifDefined()
                         "#endif";
     simplecpp::DUI dui;
     ASSERT_EQUALS("", preprocess(code, dui));
-    dui.defines.push_back("A=1");
+    dui.defines.emplace_back("A=1");
     ASSERT_EQUALS("\nX", preprocess(code, dui));
 }
 
@@ -1572,7 +1841,7 @@ static void ifDefinedNoPar()
                         "#endif";
     simplecpp::DUI dui;
     ASSERT_EQUALS("", preprocess(code, dui));
-    dui.defines.push_back("A=1");
+    dui.defines.emplace_back("A=1");
     ASSERT_EQUALS("\nX", preprocess(code, dui));
 }
 
@@ -1584,7 +1853,7 @@ static void ifDefinedNested()
                         "#endif";
     simplecpp::DUI dui;
     ASSERT_EQUALS("", preprocess(code, dui));
-    dui.defines.push_back("FOO=1");
+    dui.defines.emplace_back("FOO=1");
     ASSERT_EQUALS("\n\nX", preprocess(code, dui));
 }
 
@@ -1596,7 +1865,7 @@ static void ifDefinedNestedNoPar()
                         "#endif";
     simplecpp::DUI dui;
     ASSERT_EQUALS("", preprocess(code, dui));
-    dui.defines.push_back("FOO=1");
+    dui.defines.emplace_back("FOO=1");
     ASSERT_EQUALS("\n\nX", preprocess(code, dui));
 }
 
@@ -1630,6 +1899,17 @@ static void ifDefinedHashHash()
     ASSERT_EQUALS("file0,4,#error,#error FOO is enabled\n", toString(outputList));
 }
 
+static void ifDefinedHashHash2()
+{
+    // #409
+    // do not crash when expanding P()  (as ## rhs is "null")
+    // note: gcc outputs "defined E"
+    const char code[] = "#define P(p)defined E##p\n"
+                        "P()\n";
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("\n0", preprocess(code, &outputList));
+}
+
 static void ifLogical()
 {
     const char code[] = "#if defined(A) || defined(B)\n"
@@ -1638,10 +1918,10 @@ static void ifLogical()
     simplecpp::DUI dui;
     ASSERT_EQUALS("", preprocess(code, dui));
     dui.defines.clear();
-    dui.defines.push_back("A=1");
+    dui.defines.emplace_back("A=1");
     ASSERT_EQUALS("\nX", preprocess(code, dui));
     dui.defines.clear();
-    dui.defines.push_back("B=1");
+    dui.defines.emplace_back("B=1");
     ASSERT_EQUALS("\nX", preprocess(code, dui));
 }
 
@@ -1750,12 +2030,21 @@ static void ifexpr()
     ASSERT_EQUALS("\n\n1", preprocess(code));
 }
 
+static void ifUndefFuncStyleMacro()
+{
+    const char code[] = "#if A(<dir/file.h>)\n"
+                        "#endif\n";
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("", preprocess(code, &outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,failed to evaluate #if condition, undefined function-like macro invocation: A( ... )\n", toString(outputList));
+}
+
 static void location1()
 {
     const char *code;
 
     code =  "# 1 \"main.c\"\n\n\n"
-            "x";
+           "x";
     ASSERT_EQUALS("\n#line 3 \"main.c\"\nx", preprocess(code));
 }
 
@@ -1809,6 +2098,77 @@ static void location5()
                   "int x ;", preprocess(code));
 }
 
+static void location6()
+{
+    const char code[] =
+        "#line 3\n"
+        "__LINE__ __FILE__\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "3 \"\"",
+                  preprocess(code));
+}
+
+static void location7()
+{
+    const char code[] =
+        "#line 3 \"file.c\"\n"
+        "__LINE__ __FILE__\n";
+    ASSERT_EQUALS("\n"
+                  "#line 3 \"file.c\"\n"
+                  "3 \"file.c\"",
+                  preprocess(code));
+}
+
+static void location8()
+{
+    const char code[] =
+        "# 3\n"
+        "__LINE__ __FILE__\n";
+    ASSERT_EQUALS("\n"
+                  "2 \"\"", // TODO: should say 3
+                  preprocess(code));
+}
+
+static void location9()
+{
+    const char code[] =
+        "# 3 \"file.c\"\n"
+        "__LINE__ __FILE__\n";
+    ASSERT_EQUALS("\n"
+                  "#line 3 \"file.c\"\n"
+                  "3 \"file.c\"",
+                  preprocess(code));
+}
+
+static void location10()
+{
+    const char code[] =
+        "#line 3\n"
+        "__LINE__ __FILE__\n";
+    ASSERT_EQUALS("\n"
+                  "\n" // TODO: should this have the #line marker?
+                  "3 \"\"",
+                  preprocess(code));
+}
+
+static void location11()
+{
+    const char code[] =
+        "#line 3 \"file.c\"\n"
+        "__LINE__ __FILE__\n"
+        "#line 33 \"file2.c\"\n"
+        "__LINE__ __FILE__\n";
+    ASSERT_EQUALS("\n"
+                  "#line 3 \"file.c\"\n"
+                  "3 \"file.c\"\n"
+                  "#line 33 \"file2.c\"\n"
+                  "33 \"file2.c\"",
+                  preprocess(code));
+}
+
+// TODO: test #file/#endfile
+
 static void missingHeader1()
 {
     const char code[] = "#include \"notexist.h\"\n";
@@ -1821,12 +2181,14 @@ static void missingHeader2()
 {
     const char code[] = "#include \"foo.h\"\n"; // this file exists
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
-    filedata["foo.h"] = nullptr;
+    simplecpp::FileDataCache cache;
+    cache.insert({"foo.h", simplecpp::TokenList(files)});
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::DUI dui;
+    dui.includePaths.emplace_back(".");
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
     ASSERT_EQUALS("", toString(outputList));
 }
 
@@ -1842,7 +2204,9 @@ static void missingHeader4()
 {
     const char code[] = "#/**/include <>\n";
     simplecpp::OutputList outputList;
-    ASSERT_EQUALS("", preprocess(code, &outputList));
+    simplecpp::DUI dui;
+    dui.removeComments = true; // TODO: remove this
+    ASSERT_EQUALS("", preprocess(code, dui, &outputList));
     ASSERT_EQUALS("file0,1,syntax_error,No header in #include\n", toString(outputList));
 }
 
@@ -1850,13 +2214,15 @@ static void nestedInclude()
 {
     const char code[] = "#include \"test.h\"\n";
     std::vector<std::string> files;
-    simplecpp::TokenList rawtokens = makeTokenList(code,files,"test.h");
-    std::map<std::string, simplecpp::TokenList*> filedata;
-    filedata["test.h"] = &rawtokens;
+    const simplecpp::TokenList rawtokens = makeTokenList(code,files,"test.h");
+    simplecpp::FileDataCache cache;
+    cache.insert({"test.h", rawtokens});
 
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::DUI dui;
+    dui.includePaths.emplace_back(".");
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
 
     ASSERT_EQUALS("file0,1,include_nested_too_deeply,#include nested too deeply\n", toString(outputList));
 }
@@ -1865,14 +2231,59 @@ static void systemInclude()
 {
     const char code[] = "#include <limits.h>\n";
     std::vector<std::string> files;
-    simplecpp::TokenList rawtokens = makeTokenList(code,files,"local/limits.h");
-    std::map<std::string, simplecpp::TokenList*> filedata;
-    filedata["limits.h"] = nullptr;
-    filedata["local/limits.h"] = &rawtokens;
+    const simplecpp::TokenList rawtokens = makeTokenList(code,files,"local/limits.h");
+    simplecpp::FileDataCache cache;
+    cache.insert({"include/limits.h", simplecpp::TokenList(files)});
+    cache.insert({"local/limits.h", rawtokens});
 
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::DUI dui;
+    dui.includePaths.emplace_back("include");
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
+
+    ASSERT_EQUALS("", toString(outputList));
+}
+
+static void circularInclude()
+{
+    std::vector<std::string> files;
+    simplecpp::FileDataCache cache;
+
+    {
+        const char *const path = "test.h";
+        const char code[] =
+            "#ifndef TEST_H\n"
+            "#define TEST_H\n"
+            "#include \"a/a.h\"\n"
+            "#endif\n"
+        ;
+        cache.insert({path, makeTokenList(code, files, path)});
+    }
+
+    {
+        const char *const path = "a/a.h";
+        const char code[] =
+            "#ifndef A_H\n"
+            "#define A_H\n"
+            "#include \"../test.h\"\n"
+            "#endif\n"
+        ;
+        cache.insert({path, makeTokenList(code, files, path)});
+    }
+
+    simplecpp::OutputList outputList;
+    simplecpp::TokenList tokens2(files);
+    {
+        std::vector<std::string> filenames;
+        const simplecpp::DUI dui;
+
+        const char code[] = "#include \"test.h\"\n";
+        const simplecpp::TokenList rawtokens = makeTokenList(code, files, "test.cpp");
+
+        cache = simplecpp::load(rawtokens, filenames, dui, &outputList, std::move(cache));
+        simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
+    }
 
     ASSERT_EQUALS("", toString(outputList));
 }
@@ -1894,9 +2305,9 @@ static void multiline2()
     simplecpp::TokenList rawtokens = makeTokenList(code,files);
     ASSERT_EQUALS("# define A /**/ 1\n\nA", rawtokens.stringify());
     rawtokens.removeComments();
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("\n\n1", tokens2.stringify());
 }
 
@@ -1909,9 +2320,9 @@ static void multiline3()   // #28 - macro with multiline comment
     simplecpp::TokenList rawtokens = makeTokenList(code,files);
     ASSERT_EQUALS("# define A /*           */ 1\n\nA", rawtokens.stringify());
     rawtokens.removeComments();
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("\n\n1", tokens2.stringify());
 }
 
@@ -1925,9 +2336,9 @@ static void multiline4()   // #28 - macro with multiline comment
     simplecpp::TokenList rawtokens = makeTokenList(code,files);
     ASSERT_EQUALS("# define A /*           */ 1\n\n\nA", rawtokens.stringify());
     rawtokens.removeComments();
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("\n\n\n1", tokens2.stringify());
 }
 
@@ -2036,24 +2447,26 @@ static void include2()
 static void include3()   // #16 - crash when expanding macro from header
 {
     const char code_c[] = "#include \"A.h\"\n"
-                          "glue(1,2,3,4)\n" ;
+                          "glue(1,2,3,4)\n";
     const char code_h[] = "#define glue(a,b,c,d) a##b##c##d\n";
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("A.c", files[0]);
     ASSERT_EQUALS("A.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["A.c"] = &rawtokens_c;
-    filedata["A.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"A.c", rawtokens_c});
+    cache.insert({"A.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, simplecpp::DUI());
+    simplecpp::DUI dui;
+    dui.includePaths.emplace_back(".");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n1234", out.stringify());
 }
@@ -2061,26 +2474,27 @@ static void include3()   // #16 - crash when expanding macro from header
 
 static void include4()   // #27 - -include
 {
-    const char code_c[] = "X\n" ;
+    const char code_c[] = "X\n";
     const char code_h[] = "#define X 123\n";
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "27.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "27.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "27.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "27.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("27.c", files[0]);
     ASSERT_EQUALS("27.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["27.c"] = &rawtokens_c;
-    filedata["27.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"27.c", rawtokens_c});
+    cache.insert({"27.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includes.push_back("27.h");
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, dui);
+    dui.includePaths.emplace_back(".");
+    dui.includes.emplace_back("27.h");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("123", out.stringify());
 }
@@ -2092,19 +2506,21 @@ static void include5()    // #3 - handle #include MACRO
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("3.c", files[0]);
     ASSERT_EQUALS("3.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["3.c"] = &rawtokens_c;
-    filedata["3.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"3.c", rawtokens_c});
+    cache.insert({"3.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, simplecpp::DUI());
+    simplecpp::DUI dui;
+    dui.includePaths.emplace_back(".");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 1 \"3.h\"\n123", out.stringify());
 }
@@ -2115,16 +2531,16 @@ static void include6()   // #57 - incomplete macro  #include MACRO(,)
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens = makeTokenList(code, files, "57.c");
+    const simplecpp::TokenList rawtokens = makeTokenList(code, files, "57.c");
 
     ASSERT_EQUALS(1U, files.size());
     ASSERT_EQUALS("57.c", files[0]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["57.c"] = &rawtokens;
+    simplecpp::FileDataCache cache;
+    cache.insert({"57.c", rawtokens});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(out, rawtokens, files, cache, simplecpp::DUI());
 }
 
 
@@ -2136,21 +2552,21 @@ static void include7()    // #include MACRO
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("3.c", files[0]);
     ASSERT_EQUALS("3.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["3.c"] = &rawtokens_c;
-    filedata["3.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"3.c", rawtokens_c});
+    cache.insert({"3.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, dui);
+    dui.includePaths.emplace_back(".");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 1 \"3.h\"\n123", out.stringify());
 }
@@ -2174,21 +2590,21 @@ static void include9()
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "1.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "1.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "1.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "1.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("1.c", files[0]);
     ASSERT_EQUALS("1.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["1.c"] = &rawtokens_c;
-    filedata["1.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"1.c", rawtokens_c});
+    cache.insert({"1.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, dui);
+    dui.includePaths.emplace_back(".");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 2 \"1.h\"\nx = 1 ;", out.stringify());
 }
@@ -2345,7 +2761,7 @@ static void readfile_file_not_found()
     simplecpp::OutputList outputList;
     std::vector<std::string> files;
     (void)simplecpp::TokenList("NotAFile", files, &outputList);
-    ASSERT_EQUALS("file0,1,file_not_found,File is missing: NotAFile\n", toString(outputList));
+    ASSERT_EQUALS("file0,0,file_not_found,File is missing: NotAFile\n", toString(outputList));
 }
 
 static void stringify1()
@@ -2356,19 +2772,21 @@ static void stringify1()
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("A.c", files[0]);
     ASSERT_EQUALS("A.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["A.c"] = &rawtokens_c;
-    filedata["A.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"A.c", rawtokens_c});
+    cache.insert({"A.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, simplecpp::DUI());
+    simplecpp::DUI dui;
+    dui.includePaths.emplace_back(".");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 1 \"A.h\"\n1\n2\n#line 1 \"A.h\"\n1\n2", out.stringify());
 }
@@ -2378,10 +2796,10 @@ static void tokenMacro1()
     const char code[] = "#define A 123\n"
                         "A";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("A", tokenList.cback()->macro);
 }
 
@@ -2390,10 +2808,10 @@ static void tokenMacro2()
     const char code[] = "#define ADD(X,Y) X+Y\n"
                         "ADD(1,2)";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token *tok = tokenList.cfront();
     ASSERT_EQUALS("1", tok->str());
     ASSERT_EQUALS("", tok->macro);
@@ -2411,10 +2829,10 @@ static void tokenMacro3()
                         "#define FRED  1\n"
                         "ADD(FRED,2)";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token *tok = tokenList.cfront();
     ASSERT_EQUALS("1", tok->str());
     ASSERT_EQUALS("FRED", tok->macro);
@@ -2432,10 +2850,10 @@ static void tokenMacro4()
                         "#define B 1\n"
                         "A";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token * const tok = tokenList.cfront();
     ASSERT_EQUALS("1", tok->str());
     ASSERT_EQUALS("A", tok->macro);
@@ -2447,10 +2865,10 @@ static void tokenMacro5()
                         "#define SET_BPF_JUMP(code) SET_BPF(D | code)\n"
                         "SET_BPF_JUMP(A | B | C);";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token * const tok = tokenList.cfront()->next;
     ASSERT_EQUALS("D", tok->str());
     ASSERT_EQUALS("SET_BPF_JUMP", tok->macro);
@@ -2470,7 +2888,7 @@ static void userdef()
 {
     const char code[] = "#ifdef A\n123\n#endif\n";
     simplecpp::DUI dui;
-    dui.defines.push_back("A=1");
+    dui.defines.emplace_back("A=1");
     ASSERT_EQUALS("\n123", preprocess(code, dui));
 }
 
@@ -2712,6 +3130,7 @@ static void stdcVersionDefine()
                         "  __STDC_VERSION__\n"
                         "#endif\n";
     simplecpp::DUI dui;
+    ASSERT_EQUALS("", preprocess(code, dui));
     dui.std = "c11";
     ASSERT_EQUALS("\n201112L", preprocess(code, dui));
 }
@@ -2722,6 +3141,7 @@ static void cpluscplusDefine()
                         "  __cplusplus\n"
                         "#endif\n";
     simplecpp::DUI dui;
+    ASSERT_EQUALS("", preprocess(code, dui));
     dui.std = "c++11";
     ASSERT_EQUALS("\n201103L", preprocess(code, dui));
 }
@@ -2815,7 +3235,7 @@ static void stdValid()
 static void assertToken(const std::string& s, bool name, bool number, bool comment, char op, int line)
 {
     const std::vector<std::string> f;
-    const simplecpp::Location l(f);
+    const simplecpp::Location l;
     const simplecpp::Token t(s, l);
     assertEquals(name, t.name, line);
     assertEquals(number, t.number, line);
@@ -2884,8 +3304,8 @@ static void preprocess_files()
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("", *files.cbegin());
 
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens, files, filedata, simplecpp::DUI(), nullptr);
+        simplecpp::FileDataCache cache;
+        simplecpp::preprocess(tokens2, tokens, files, cache, simplecpp::DUI(), nullptr);
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("", *files.cbegin());
     }
@@ -2901,13 +3321,173 @@ static void preprocess_files()
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("test.cpp", *files.cbegin());
 
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens, files, filedata, simplecpp::DUI(), nullptr);
+        simplecpp::FileDataCache cache;
+        simplecpp::preprocess(tokens2, tokens, files, cache, simplecpp::DUI(), nullptr);
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("test.cpp", *files.cbegin());
     }
 }
 
+static void tokenlist_api()
+{
+    std::vector<std::string> filenames;
+#  if !defined(__cpp_lib_string_view) && !defined(__cpp_lib_span)
+    // sized array + size
+    {
+        char input[] = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList(input,sizeof(input),filenames,"");
+    }
+    {
+        const char input[] = "code";
+        simplecpp::TokenList(input,sizeof(input),filenames,"");
+    }
+    {
+        unsigned char input[] = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList(input,sizeof(input),filenames,"");
+    }
+    {
+        const unsigned char input[] = "code";
+        simplecpp::TokenList(input,sizeof(input),filenames,"");
+    }
+#endif // !defined(__cpp_lib_string_view) && !defined(__cpp_lib_span)
+    // pointer via View
+    {
+        const char * const input = "code";
+        simplecpp::TokenList({input},filenames,"");
+    }
+    // sized array via View
+    {
+        char input[] = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList(simplecpp::View{input},filenames,"");
+    }
+    {
+        const char input[] = "code";
+        simplecpp::TokenList(simplecpp::View{input},filenames,"");
+    }
+    // sized array + size via View/std::span
+    {
+        char input[] = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList({input,sizeof(input)},filenames,"");
+    }
+    {
+        const char input[] = "code";
+        simplecpp::TokenList({input,sizeof(input)},filenames,"");
+    }
+    // sized array
+    {
+        char input[] = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList(input,filenames,"");
+    }
+    {
+        const char input[] = "code";
+        simplecpp::TokenList(input,filenames,"");
+    }
+    {
+        unsigned char input[] = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList(input,filenames,"");
+    }
+    {
+        const unsigned char input[] = "code";
+        simplecpp::TokenList(input,filenames,"");
+    }
+    // std::string via View/std::span (implicit)
+    {
+        std::string input = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList(input,filenames,"");
+    }
+    {
+        const std::string input = "code";
+        simplecpp::TokenList(input,filenames,"");
+    }
+    // std::string via View/std::span (explicit)
+    {
+        std::string input = "code"; // NOLINT(misc-const-correctness)
+        simplecpp::TokenList({input},filenames,"");
+    }
+    {
+        const std::string input = "code";
+        simplecpp::TokenList({input},filenames,"");
+    }
+
+    // this test is to make sure the safe APIs are compiling
+#ifdef __cpp_lib_string_view
+    {
+        const char input[] = "code";
+        const std::string_view sv = input;
+        // std::string_view can be implicitly converted into a std::span
+        simplecpp::TokenList(sv,filenames,"");
+    }
+#endif // __cpp_lib_string_view
+#ifdef __cpp_lib_span
+    {
+        char input[] = "code";
+        const std::span sp = input;
+        simplecpp::TokenList(sp,filenames,"");
+    }
+    {
+        const char input[] = "code";
+        const std::span sp = input;
+        simplecpp::TokenList(sp,filenames,"");
+    }
+    {
+        unsigned char input[] = "code";
+        const std::span sp = input;
+        simplecpp::TokenList(sp,filenames,"");
+    }
+    {
+        const unsigned char input[] = "code";
+        const std::span sp = input;
+        simplecpp::TokenList(sp,filenames,"");
+    }
+#endif // __cpp_lib_span
+}
+
+static void bad_macro_syntax() // #616
+{
+    simplecpp::DUI dui;
+    dui.defines.emplace_back("\"");
+
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("", preprocess("", dui, &outputList));
+    ASSERT_EQUALS(1, outputList.size());
+    ASSERT_EQUALS(simplecpp::Output::Type::DUI_ERROR, outputList.cbegin()->type);
+    ASSERT_EQUALS("bad macro syntax. macroname=\" value=1", outputList.cbegin()->msg);
+}
+
+static void isAbsolutePath() {
+#ifdef _WIN32
+    ASSERT_EQUALS(true, simplecpp::isAbsolutePath("C:\\foo\\bar"));
+    ASSERT_EQUALS(true, simplecpp::isAbsolutePath("C:/foo/bar"));
+    ASSERT_EQUALS(true, simplecpp::isAbsolutePath("\\\\foo\\bar"));
+
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("foo\\bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("foo/bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("foo.cpp"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("C:foo.cpp"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("C:foo\\bar.cpp"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("bar.cpp"));
+    //ASSERT_EQUALS(true, simplecpp::isAbsolutePath("\\")); // TODO
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("0:\\foo\\bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("0:/foo/bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("\\foo\\bar"));
+    //ASSERT_EQUALS(false, simplecpp::isAbsolutePath("\\\\")); // TODO
+    //ASSERT_EQUALS(false, simplecpp::isAbsolutePath("//")); // TODO
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("/foo/bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("/"));
+#else
+    ASSERT_EQUALS(true, simplecpp::isAbsolutePath("/foo/bar"));
+    ASSERT_EQUALS(true, simplecpp::isAbsolutePath("/"));
+    ASSERT_EQUALS(true, simplecpp::isAbsolutePath("//host/foo/bar"));
+
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("foo/bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("foo.cpp"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("C:\\foo\\bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("C:/foo/bar"));
+    ASSERT_EQUALS(false, simplecpp::isAbsolutePath("\\\\foo\\bar"));
+#endif
+}
+
+// crashes detected by fuzzer
 static void fuzz_crash()
 {
     {
@@ -2915,6 +3495,27 @@ static void fuzz_crash()
                             "n\n";
         (void)preprocess(code, simplecpp::DUI()); // do not crash
     }
+    { // #346
+        const char code[] = "#define foo(intp)f##oo(intp\n"
+                            "foo(f##oo(intp))\n";
+        (void)preprocess(code, simplecpp::DUI()); // do not crash
+    }
+    { // #546
+        const char code[] = "#if __has_include<\n";
+        simplecpp::OutputList outputList;
+        ASSERT_EQUALS("", preprocess(code, &outputList)); // do not crash
+        ASSERT_EQUALS("file0,1,syntax_error,failed to evaluate #if condition\n", toString(outputList));
+    }
+}
+
+// memory leaks detected by LSAN/valgrind
+static void leak()
+{
+    { // #498
+        const char code[] = "#define e(...)__VA_OPT__()\n"
+                            "#define e\n";
+        (void)preprocess(code, simplecpp::DUI());
+    }
 }
 
 int main(int argc, char **argv)
@@ -2975,6 +3576,10 @@ int main(int argc, char **argv)
     TEST_CASE(define_define_17);
     TEST_CASE(define_define_18);
     TEST_CASE(define_define_19);
+    TEST_CASE(define_define_20); // 384 arg contains comma
+    TEST_CASE(define_define_21);
+    TEST_CASE(define_define_22); // #400
+    TEST_CASE(define_define_23); // #403 - crash, infinite recursion
     TEST_CASE(define_va_args_1);
     TEST_CASE(define_va_args_2);
     TEST_CASE(define_va_args_3);
@@ -2984,6 +3589,9 @@ int main(int argc, char **argv)
     TEST_CASE(define_va_opt_3);
     TEST_CASE(define_va_opt_4);
     TEST_CASE(define_va_opt_5);
+    TEST_CASE(define_va_opt_6);
+    TEST_CASE(define_va_opt_7);
+    TEST_CASE(define_va_opt_8);
 
     TEST_CASE(pragma_backslash); // multiline pragma directive
 
@@ -3031,6 +3639,7 @@ int main(int argc, char **argv)
     TEST_CASE(hashhash_invalid_string_number);
     TEST_CASE(hashhash_invalid_missing_args);
     TEST_CASE(hashhash_null_stmt);
+    TEST_CASE(hashhash_empty_va_args);
     // C standard, 5.1.1.2, paragraph 4:
     //    If a character sequence that matches the syntax of a universal
     //    character name is produced by token concatenation (6.10.3.3),
@@ -3043,6 +3652,12 @@ int main(int argc, char **argv)
     TEST_CASE(has_include_3);
     TEST_CASE(has_include_4);
     TEST_CASE(has_include_5);
+    TEST_CASE(has_include_6);
+
+    TEST_CASE(strict_ansi_1);
+    TEST_CASE(strict_ansi_2);
+    TEST_CASE(strict_ansi_3);
+    TEST_CASE(strict_ansi_4);
 
     TEST_CASE(ifdef1);
     TEST_CASE(ifdef2);
@@ -3056,6 +3671,7 @@ int main(int argc, char **argv)
     TEST_CASE(ifDefinedInvalid1);
     TEST_CASE(ifDefinedInvalid2);
     TEST_CASE(ifDefinedHashHash);
+    TEST_CASE(ifDefinedHashHash2);
     TEST_CASE(ifLogical);
     TEST_CASE(ifSizeof);
     TEST_CASE(elif);
@@ -3064,12 +3680,19 @@ int main(int argc, char **argv)
     TEST_CASE(ifdiv0);
     TEST_CASE(ifalt); // using "and", "or", etc
     TEST_CASE(ifexpr);
+    TEST_CASE(ifUndefFuncStyleMacro);
 
     TEST_CASE(location1);
     TEST_CASE(location2);
     TEST_CASE(location3);
     TEST_CASE(location4);
     TEST_CASE(location5);
+    TEST_CASE(location6);
+    TEST_CASE(location7);
+    TEST_CASE(location8);
+    TEST_CASE(location9);
+    TEST_CASE(location10);
+    TEST_CASE(location11);
 
     TEST_CASE(missingHeader1);
     TEST_CASE(missingHeader2);
@@ -3077,6 +3700,7 @@ int main(int argc, char **argv)
     TEST_CASE(missingHeader4);
     TEST_CASE(nestedInclude);
     TEST_CASE(systemInclude);
+    TEST_CASE(circularInclude);
 
     TEST_CASE(nullDirective1);
     TEST_CASE(nullDirective2);
@@ -3153,7 +3777,15 @@ int main(int argc, char **argv)
 
     TEST_CASE(preprocess_files);
 
+    TEST_CASE(tokenlist_api);
+
+    TEST_CASE(isAbsolutePath);
+
+    TEST_CASE(bad_macro_syntax);
+
     TEST_CASE(fuzz_crash);
 
+    TEST_CASE(leak);
+
     return numberOfFailedAssertions > 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 }
diff --git a/testsuite/clang-preprocessor-tests/macro_fn_va_opt.c b/testsuite/clang-preprocessor-tests/macro_fn_va_opt.c
new file mode 100644
index 00000000..ccb09e95
--- /dev/null
+++ b/testsuite/clang-preprocessor-tests/macro_fn_va_opt.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -E %s | grep '^    printf( "%%s" , "Hello" );$'
+
+#define P( x, ...) printf( x __VA_OPT__(,) __VA_ARGS__ )
+#define PF( x, ...) P( x __VA_OPT__(,) __VA_ARGS__ )
+
+int main()
+{
+    PF( "%s", "Hello" );
+    PF( "Hello", );
+    PF( "Hello" );
+    PF( , );
+    PF( );
+}
diff --git a/testutils.py b/testutils.py
new file mode 100644
index 00000000..55a2686d
--- /dev/null
+++ b/testutils.py
@@ -0,0 +1,57 @@
+import os
+import subprocess
+import json
+
+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
+
+    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 return_code, stdout, stderr
+
+def simplecpp(args = [], cwd = None):
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+    if 'SIMPLECPP_EXE_PATH' in os.environ:
+        simplecpp_path = os.environ['SIMPLECPP_EXE_PATH']
+    else:
+        simplecpp_path = os.path.join(dir_path, "simplecpp")
+    return __run_subprocess([simplecpp_path] + args, cwd = cwd)
+
+def quoted_string(s):
+    return json.dumps(str(s))
+
+def format_include_path_arg(include_path):
+    return f"-I{str(include_path)}"
+
+def format_include(include, is_sys_header=False):
+    if is_sys_header:
+        return f"<{quoted_string(include)[1:-1]}>"
+    else:
+        return quoted_string(include)