diff --git a/.clang-tidy b/.clang-tidy
index c03da523..e0b384bf 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -4,6 +4,7 @@ Checks: >
         -abseil-*,
         -altera-*,
         -android-*,
+        -boost-*,
         -cert-*,
         -clang-analyzer-*,
         -cppcoreguidelines-*,
@@ -17,11 +18,12 @@ Checks: >
         -objc-*,
         -openmp-*,
         -zircon-*,
-        -boost-use-ranges,
         -bugprone-branch-clone,
         -bugprone-easily-swappable-parameters,
         -bugprone-narrowing-conversions,
         -bugprone-switch-missing-default-case,
+        -bugprone-throwing-static-initialization,
+        -bugprone-unchecked-string-to-number-conversion,
         -concurrency-mt-unsafe,
         -misc-no-recursion,
         -misc-non-private-member-variables-in-classes,
@@ -29,16 +31,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 +42,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..390de83d
--- /dev/null
+++ b/.github/workflows/CI-mingw.yml
@@ -0,0 +1,141 @@
+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++
+          # the mingw-w64-i686-clang package is no longer available
+          - msystem: MINGW32
+            compiler: clang++
+      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 cb498b5e..cdda088b 100644
--- a/.github/workflows/CI-unixish.yml
+++ b/.github/workflows/CI-unixish.yml
@@ -2,13 +2,25 @@ name: CI-unixish
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
 jobs:
   build:
 
     strategy:
       matrix:
-        compiler: [clang++, g++]
-        os: [ubuntu-22.04, ubuntu-24.04, macos-13, macos-14, macos-15]
+        os: [ubuntu-22.04, ubuntu-22.04-arm, ubuntu-24.04, ubuntu-24.04-arm, macos-14, macos-15, macos-15-intel, macos-26, macos-26-intel]
+        compiler: [clang++]
+        include:
+          - os: ubuntu-22.04
+            compiler: g++
+          - os: ubuntu-22.04-arm
+            compiler: g++
+          - os: ubuntu-24.04
+            compiler: g++
+          - os: ubuntu-24.04-arm
+            compiler: g++
       fail-fast: false
 
     runs-on: ${{ matrix.os }}
@@ -17,7 +29,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,16 +47,18 @@ 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 python3
+        brew install coreutils
 
     - name: Install missing Python packages
       run: |
@@ -42,22 +66,39 @@ jobs:
         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: integration test
+    - name: make (c++14)
       run: |
-        python3 -m pytest integration_test.py -vv
+        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: |
@@ -67,40 +108,44 @@ 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 CXXOPTS="-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 CXXOPTS="-stdlib=libc++ -g3 -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG" LDOPTS="-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 CXXOPTS="-O2 -g3 -fsanitize=address" LDOPTS="-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 CXXOPTS="-O2 -g3 -fsanitize=undefined -fno-sanitize=signed-integer-overflow" LDOPTS="-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
 
@@ -109,4 +154,45 @@ jobs:
       if: false && matrix.os == 'ubuntu-24.04' && matrix.compiler == 'clang++'
       run: |
         make clean
-        make -j$(nproc) test selfcheck CXXOPTS="-O2 -g3 -stdlib=libc++ -fsanitize=memory" LDOPTS="-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 971f3827..0d1e62e2 100644
--- a/.github/workflows/CI-windows.yml
+++ b/.github/workflows/CI-windows.yml
@@ -6,31 +6,43 @@ name: CI-windows
 
 on: [push,pull_request]
 
+permissions:
+  contents: read
+
 defaults:
   run:
     shell: cmd
-    
+
 jobs:
 
   build:
     strategy:
       matrix:
-        os: [windows-2022, windows-2025]
+        os: [windows-2022, windows-2025, windows-11-arm]
         config: [Release, Debug]
+        include:
+        - os: windows-2022
+          sln: sln
+        - os: windows-2025
+          sln: slnx
+        - os: windows-11-arm
+          sln: sln
       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: Set up Python 3.13
-        uses: actions/setup-python@v5
+      - name: Set up Python
+        uses: actions/setup-python@v6
         with:
-          python-version: '3.13'
+          python-version: '3.14'
           check-latest: true
 
       - name: Install missing Python packages
@@ -40,12 +52,12 @@ jobs:
 
       - name: Run CMake
         run: |
-          cmake -G "Visual Studio 17 2022" -A x64 . || exit /b !errorlevel!
+          cmake -A x64 -Werror=dev --warn-uninitialized -DCMAKE_COMPILE_WARNING_AS_ERROR=On . || exit /b !errorlevel!
 
       - name: Build
         run: |
-           msbuild -m simplecpp.sln /p:Configuration=${{ matrix.config }} /p:Platform=x64 || exit /b !errorlevel!
-           
+           msbuild -m simplecpp.${{ matrix.sln }} /p:Configuration=${{ matrix.config }} /p:Platform=x64 || exit /b !errorlevel!
+
       - name: Test
         run: |
           .\${{ matrix.config }}\testrunner.exe || exit /b !errorlevel!
@@ -58,4 +70,20 @@ jobs:
         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 -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.${{ matrix.sln }} /p:Configuration=${{ matrix.config }} /p:Platform=x64 || exit /b !errorlevel!
+
+      - name: Run CMake (c++20)
+        run: |
+          cmake -S . -B build.cxx20 -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.${{ matrix.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 a2f7b6dc..333672d7 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 20
-          sudo apt-get install clang-tidy-20
+          sudo ./llvm.sh 22
+          sudo apt-get install clang-tidy-22
 
       - name: Verify clang-tidy configuration
         run: |
-          clang-tidy-20 --verify-config
+          clang-tidy-22 --verify-config
 
       - name: Prepare CMake
         run: |
-          cmake -S . -B cmake.output -G "Unix Makefiles" -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+          cmake -S . -B cmake.output -Werror=dev --warn-uninitialized -DCMAKE_CXX_STANDARD=23 -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
         env:
-          CXX: clang-20
+          CXX: clang-22
 
       - name: Clang-Tidy
         run: |
-          run-clang-tidy-20 -q -j $(nproc) -p=cmake.output
+          run-clang-tidy-22 -q -j $(nproc) -enable-check-profile -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 113cf360..34d9c55d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,7 @@
 *.app
 simplecpp
 testrunner
+/.runformat-uncrustify
 
 # CLion
 /.idea
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 6ab0166e..0a90efae 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,42 +19,69 @@ function(add_compile_options_safe FLAG)
     endif()
 endfunction()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+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(-Wno-long-long)
     add_compile_options(-Wpacked)                   #
     add_compile_options(-Wredundant-decls)          # if anything is declared more than once in the same scope
     add_compile_options(-Wundef)
-    add_compile_options(-Wno-missing-braces)
-    add_compile_options(-Wno-sign-compare)
-    add_compile_options(-Wno-multichar)
     add_compile_options(-Woverloaded-virtual)       # when a function declaration hides virtual functions from a base class
 
     add_compile_options(-Wsuggest-attribute=noreturn)
-    add_compile_options_safe(-Wuseless-cast)
-elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    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
@@ -66,12 +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)
 add_executable(testrunner $<TARGET_OBJECTS:simplecpp_obj> test.cpp)
+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 d899d2cd..b7b54597 100644
--- a/Makefile
+++ b/Makefile
@@ -1,11 +1,18 @@
 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++11 -g $(CXXOPTS)
+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
@@ -16,7 +23,7 @@ test:	testrunner	simplecpp
 	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/README.md b/README.md
index e4bdb2f1..dae242ea 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # Simple C/C++ preprocessor
 
+NOTE: This repository was recently moved from https://github.com/danmar/simplecpp to https://github.com/cppcheck-opensource/simplecpp. Please make sure to update all your references to it accordingly.
+
 This is a simple C/C++ preprocessor.
 
 The goal is to have good conformance with the C and C++ standards and to handle nonstandard preprocessor extensions in gcc / clang / visual studio preprocessors. Most of the preprocessor testcases in gcc and clang are handled OK by 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
index a59ae338..c000b27b 100644
--- a/integration_test.py
+++ b/integration_test.py
@@ -298,3 +298,221 @@ def test_pragma_once_matching(record_property, tmpdir):
 
     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'
+
+def test_utf16_bom(tmpdir):
+    test_file = os.path.join(tmpdir, "test.cpp")
+    with open(test_file, 'wb') as f:
+        f.write(b'\xFF\xFE\x3B\x00')
+
+    args = [test_file]
+
+    exitcode, stdout, stderr = simplecpp(args, cwd=tmpdir)
+
+    assert exitcode == 0
+    assert stderr == ''
+    assert stdout == ';\n'
diff --git a/main.cpp b/main.cpp
index a6d14386..685ada12 100644
--- a/main.cpp
+++ b/main.cpp
@@ -3,24 +3,45 @@
  * Copyright (C) 2016-2023 simplecpp team
  */
 
+#define SIMPLECPP_TOKENLIST_ALLOW_PTR 0
 #include "simplecpp.h"
 
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <fstream>
 #include <iostream>
+#include <sstream>
 #include <string>
+#include <sys/stat.h>
+#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;
+    enum : std::uint8_t {
+        File,
+        Fstream,
+        Sstream,
+        CharBuffer
+    } toklist_inf = File;
     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++) {
@@ -30,49 +51,107 @@ int main(int argc, char **argv)
             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);
                 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
+                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);
                 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, "-input=",7)==0) {
                     found = true;
+                    const std::string input = arg + 7;
+                    if (input.empty()) {
+                        std::cout << "error: option -input with no value." << std::endl;
+                        error = true;
+                        break;
+                    }
+                    if (input == "file") {
+                        toklist_inf = File;
+                    } else if (input == "fstream") {
+                        toklist_inf = Fstream;
+                    } else if (input == "sstream") {
+                        toklist_inf = Sstream;
+                    } else if (input == "buffer") {
+                        toklist_inf = CharBuffer;
+                    } else {
+                        std::cout << "error: unknown input type '" << input << "'." << std::endl;
+                        error = true;
+                        break;
+                    }
                 }
                 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;
+                if (std::strcmp(arg, "-q")==0) {
+                    found = true;
+                    quiet = true;
+                }
                 break;
             case 'e':
-                error_only = true;
-                found = true;
+                if (std::strcmp(arg, "-e")==0) {
+                    found = true;
+                    error_only = true;
+                }
                 break;
             case 'f':
-                fail_on_error = true;
-                found = true;
+                if (std::strcmp(arg, "-f")==0) {
+                    fail_on_error = true;
+                    found = true;
+                }
+                break;
+            case 'l':
+                if (std::strcmp(arg, "-l")==0) {
+                    linenrs = true;
+                    found = true;
+                }
                 break;
             }
             if (!found) {
@@ -81,18 +160,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) {
@@ -104,42 +183,79 @@ int main(int argc, char **argv)
         std::cout << "  -UNAME          Undefine NAME." << std::endl;
         std::cout << "  -std=STD        Specify standard." << std::endl;
         std::cout << "  -q              Quiet mode (no output)." << std::endl;
-        std::cout << "  -is             Use std::istream interface." << std::endl;
+        std::cout << "  -input=INPUT    Specify input type - file (default), fstream, sstream, buffer." << 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 (toklist_inf == Fstream) {
+            rawtokens = new simplecpp::TokenList(f,files,filename,&outputList);
         }
-        rawtokens = new simplecpp::TokenList(f, files,filename,&outputList);
-    } else {
-        rawtokens = new simplecpp::TokenList(filename,files,&outputList);
+        else if (toklist_inf == Sstream || toklist_inf == CharBuffer) {
+            std::ostringstream oss;
+            oss << f.rdbuf();
+            f.close();
+            const std::string s = oss.str();
+            if (toklist_inf == Sstream) {
+                std::istringstream iss(s);
+                rawtokens = new simplecpp::TokenList(iss,files,filename,&outputList);
+            }
+            else {
+                rawtokens = new simplecpp::TokenList({s.data(),s.size()},files,filename,&outputList);
+            }
+        } else {
+            f.close();
+            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);
-    simplecpp::FileDataCache 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: ";
diff --git a/run-tests.py b/run-tests.py
index 5017f4c1..20f59a49 100644
--- a/run-tests.py
+++ b/run-tests.py
@@ -1,17 +1,30 @@
-
 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 = []
 
@@ -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 a43ef8c5..b2129cc9 100755
--- a/selfcheck.sh
+++ b/selfcheck.sh
@@ -1,11 +1,144 @@
-#!/bin/sh
+#!/bin/bash
 
-output=$(./simplecpp simplecpp.cpp -e -f 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 got errors which do not refer to missing system includes
+  # only fail if we got errors which do not refer to missing system includes
   if [ ! -z "$errors" ]; then
     exit $ec
   fi
-fi
\ No newline at end of file
+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=$?
+cat "$VALGRIND_REDIRECT"
+if [ $ec -ne 0 ]; then
+  exit $ec
+fi
diff --git a/simplecpp.cpp b/simplecpp.cpp
index fd327549..fc145849 100644
--- a/simplecpp.cpp
+++ b/simplecpp.cpp
@@ -3,25 +3,36 @@
  * Copyright (C) 2016-2023 simplecpp team
  */
 
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
-#  define _WIN32_WINNT 0x0602
-#  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>
@@ -56,14 +67,12 @@ static bool isOct(const std::string &s)
     return s.size()>1 && (s[0]=='0') && (s[1] >= '0') && (s[1] < '8');
 }
 
-// TODO: added an undercore since this conflicts with a function of the same name in utils.h from Cppcheck source when building Cppcheck with MSBuild
-static bool isStringLiteral_(const std::string &s)
+static bool isStringLiteral(const std::string &s)
 {
     return s.size() > 1 && (s[0]=='\"') && (*s.rbegin()=='\"');
 }
 
-// TODO: added an undercore since this conflicts with a function of the same name in utils.h from Cppcheck source when building Cppcheck with MSBuild
-static bool isCharLiteral_(const std::string &s)
+static bool isCharLiteral(const std::string &s)
 {
     // char literal patterns can include 'a', '\t', '\000', '\xff', 'abcd', and maybe ''
     // This only checks for the surrounding '' but doesn't parse the content.
@@ -170,8 +179,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) {
@@ -233,7 +240,7 @@ 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;
@@ -241,12 +248,12 @@ class simplecpp::TokenList::Stream {
     virtual bool good() = 0;
 
     unsigned char readChar() {
-        unsigned char ch = static_cast<unsigned char>(get());
+        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));
         }
@@ -268,17 +275,19 @@ class simplecpp::TokenList::Stream {
         return ch;
     }
 
-    unsigned char peekChar() {
-        unsigned char ch = static_cast<unsigned char>(peek());
+    int peekChar() {
+        int ch = peek();
+        if (ch == EOF)
+            return ch;
 
         // 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));
+            ch = (ch16 >= 0x80) ? 0xff : ch16;
         }
 
         // Handling of newlines..
@@ -342,120 +351,124 @@ class simplecpp::TokenList::Stream {
     bool isUtf16;
 };
 
-class StdIStream : public simplecpp::TokenList::Stream {
-public:
-    // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
-    explicit StdIStream(std::istream &istr)
-        : istr(istr) {
-        assert(istr.good());
-        init();
-    }
+namespace {
+    class StdIStream : public simplecpp::TokenList::Stream {
+    public:
+        // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
+        explicit StdIStream(std::istream &istr)
+            : istr(istr) {
+            assert(istr.good());
+            init();
+        }
 
-    virtual int get() override {
-        return istr.get();
-    }
-    virtual int peek() override {
-        return istr.peek();
-    }
-    virtual void unget() override {
-        istr.unget();
-    }
-    virtual bool good() override {
-        return istr.good();
-    }
+        int get() override {
+            return istr.get();
+        }
+        int peek() override {
+            return istr.peek();
+        }
+        void unget() override {
+            istr.unget();
+        }
+        bool good() override {
+            return istr.good();
+        }
 
-private:
-    std::istream &istr;
-};
+    private:
+        std::istream &istr;
+    };
 
-class StdCharBufStream : public simplecpp::TokenList::Stream {
-public:
-    // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
-    StdCharBufStream(const unsigned char* str, std::size_t size)
-        : str(str)
-        , size(size)
-        , pos(0)
-        , lastStatus(0) {
-        init();
-    }
+    class StdCharBufStream : public simplecpp::TokenList::Stream {
+    public:
+        // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
+        StdCharBufStream(const unsigned char* str, std::size_t size)
+            : str(str)
+            , size(size)
+        {
+            init();
+        }
 
-    virtual int get() override {
-        if (pos >= size)
-            return lastStatus = EOF;
-        return str[pos++];
-    }
-    virtual int peek() override {
-        if (pos >= size)
-            return lastStatus = EOF;
-        return str[pos];
-    }
-    virtual void unget() override {
-        --pos;
-    }
-    virtual bool good() override {
-        return lastStatus != EOF;
-    }
+        int get() override {
+            if (pos >= size)
+                return lastStatus = EOF;
+            return str[pos++];
+        }
+        int peek() override {
+            if (pos >= size)
+                return lastStatus = EOF;
+            return str[pos];
+        }
+        void unget() override {
+            --pos;
+        }
+        bool good() override {
+            return lastStatus != EOF;
+        }
 
-private:
-    const unsigned char *str;
-    const std::size_t size;
-    std::size_t pos;
-    int lastStatus;
-};
+    private:
+        const unsigned char *str;
+        const std::size_t size;
+        std::size_t pos{};
+        int lastStatus{};
+    };
 
-class FileStream : public simplecpp::TokenList::Stream {
-public:
-    // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
-    explicit FileStream(const std::string &filename, std::vector<std::string> &files)
-        : file(fopen(filename.c_str(), "rb"))
-        , lastCh(0)
-        , lastStatus(0) {
-        if (!file) {
-            files.push_back(filename);
-            throw simplecpp::Output(files, simplecpp::Output::FILE_NOT_FOUND, "File is missing: " + filename);
+    class FileStream : public simplecpp::TokenList::Stream {
+    public:
+        /**
+         * @throws simplecpp::Output thrown if file is not found
+         */
+        // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
+        explicit FileStream(const std::string &filename, std::vector<std::string> &files)
+            : file(fopen(filename.c_str(), "rb"))
+        {
+            if (!file) {
+                files.emplace_back(filename);
+                throw simplecpp::Output(simplecpp::Output::FILE_NOT_FOUND, {}, "File is missing: " + filename);
+            }
+            init();
         }
-        init();
-    }
 
-    ~FileStream() override {
-        fclose(file);
-        file = nullptr;
-    }
+        FileStream(const FileStream&) = delete;
+        FileStream &operator=(const FileStream&) = delete;
 
-    virtual int get() override {
-        lastStatus = lastCh = fgetc(file);
-        return lastCh;
-    }
-    virtual int peek() override {
-        // keep lastCh intact
-        const int ch = fgetc(file);
-        unget_internal(ch);
-        return ch;
-    }
-    virtual void unget() override {
-        unget_internal(lastCh);
-    }
-    virtual bool good() override {
-        return lastStatus != EOF;
-    }
+        ~FileStream() override {
+            fclose(file);
+            file = nullptr;
+        }
 
-private:
-    void unget_internal(int ch) {
-        if (isUtf16) {
-            // TODO: use ungetc() as well
-            // UTF-16 has subsequent unget() calls
-            fseek(file, -1, SEEK_CUR);
-        } else
-            ungetc(ch, file);
-    }
+        int get() override {
+            lastStatus = lastCh = fgetc(file);
+            return lastCh;
+        }
+        int peek() override {
+            // keep lastCh intact
+            const int ch = fgetc(file);
+            unget_internal(ch);
+            return ch;
+        }
+        void unget() override {
+            unget_internal(lastCh);
+        }
+        bool good() override {
+            return lastStatus != EOF;
+        }
 
-    FileStream(const FileStream&);
-    FileStream &operator=(const FileStream&);
+    private:
+        void unget_internal(int ch) {
+            if (isUtf16) {
+                // TODO: use ungetc() as well
+                // UTF-16 has subsequent unget() calls
+                fseek(file, -1, SEEK_CUR);
+            } else {
+                ungetc(ch, file);
+            }
+        }
 
-    FILE *file;
-    int lastCh;
-    int lastStatus;
-};
+        FILE *file;
+        int lastCh{};
+        int lastStatus{};
+    };
+}
 
 simplecpp::TokenList::TokenList(std::vector<std::string> &filenames) : frontToken(nullptr), backToken(nullptr), files(filenames) {}
 
@@ -466,28 +479,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)
 {
     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);
     }
 }
 
@@ -553,24 +559,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))
@@ -584,7 +600,7 @@ std::string simplecpp::TokenList::stringify() const
     return ret.str();
 }
 
-static bool isNameChar(unsigned char ch)
+static bool isNameChar(int ch)
 {
     return std::isalnum(ch) || ch == '_' || ch == '$';
 }
@@ -603,15 +619,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)
@@ -620,16 +637,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());
@@ -647,10 +664,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())
@@ -658,13 +672,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;
@@ -673,7 +686,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 {
@@ -685,33 +698,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 Token * const llNextToken = llTok->next;
+                if (!llTok->next)
                     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);
+                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();
                 }
@@ -728,8 +764,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;
@@ -737,8 +773,21 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
                     ch = stream.readChar();
                 }
                 stream.ungetChar();
-                push_back(new Token(currentToken, location));
-                location.adjust(currentToken);
+                std::string::size_type pos = 0;
+                unsigned int spliced = 0;
+                while ((pos = currentToken.find('\\', pos)) != std::string::npos) {
+                    if (pos + 1 < currentToken.size() && currentToken[pos + 1] == '\n') {
+                        currentToken.erase(pos, 2);
+                        ++spliced;
+                    } else {
+                        ++pos;
+                    }
+                }
+                if (!currentToken.empty()) {
+                    push_back(new Token(currentToken, location));
+                    location.adjust(currentToken);
+                }
+                location.line += spliced;
                 continue;
             }
         }
@@ -761,24 +810,24 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
             while (stream.good() && ch != '\n') {
                 currentToken += ch;
                 ch = stream.readChar();
-                if(ch == '\\') {
+                if (ch == '\\') {
                     TokenString tmp;
                     char tmp_ch = ch;
-                    while((stream.good()) && (tmp_ch == '\\' || tmp_ch == ' ' || tmp_ch == '\t')) {
+                    while ((stream.good()) && (tmp_ch == '\\' || tmp_ch == ' ' || tmp_ch == '\t')) {
                         tmp += tmp_ch;
                         tmp_ch = stream.readChar();
                     }
-                    if(!stream.good()) {
+                    if (!stream.good()) {
                         break;
                     }
 
-                    if(tmp_ch != '\n') {
+                    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, files, location);
+                            portabilityBackslash(outputList, location);
                         ++multiline;
                         tmp_ch = stream.readChar();
                         currentToken += '\n';
@@ -838,24 +887,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 +916,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();
 
@@ -947,7 +998,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 != '(')
@@ -970,6 +1021,14 @@ static bool isFloatSuffix(const simplecpp::Token *tok)
     return c == 'f' || c == 'l';
 }
 
+static const std::string AND("and");
+static const std::string BITAND("bitand");
+static const std::string BITOR("bitor");
+static bool isAlternativeAndBitandBitor(const simplecpp::Token* tok)
+{
+    return isAlternativeBinaryOp(tok, AND) || isAlternativeBinaryOp(tok, BITAND) || isAlternativeBinaryOp(tok, BITOR);
+}
+
 void simplecpp::TokenList::combineOperators()
 {
     std::stack<bool> executableScope;
@@ -981,7 +1040,7 @@ void simplecpp::TokenList::combineOperators()
                 continue;
             }
             const Token *prev = tok->previous;
-            while (prev && prev->isOneOf(";{}()"))
+            while (prev && prev->isOneOf(";{}("))
                 prev = prev->previous;
             executableScope.push(prev && prev->op == ')');
             continue;
@@ -1005,7 +1064,7 @@ void simplecpp::TokenList::combineOperators()
             if (tok->previous && tok->previous->number && sameline(tok->previous, tok) && tok->previous->str().find_first_of("._") == std::string::npos) {
                 tok->setstr(tok->previous->str() + '.');
                 deleteToken(tok->previous);
-                if (sameline(tok, tok->next) && (isFloatSuffix(tok->next) || (tok->next && tok->next->startsWithOneOf("AaBbCcDdEeFfPp")))) {
+                if (sameline(tok, tok->next) && (isFloatSuffix(tok->next) || (tok->next && tok->next->startsWithOneOf("AaBbCcDdEeFfPp") && !isAlternativeAndBitandBitor(tok->next)))) {
                     tok->setstr(tok->str() + tok->next->str());
                     deleteToken(tok->next);
                 }
@@ -1144,8 +1203,9 @@ void simplecpp::TokenList::constFoldMulDivRem(Token *tok)
             continue;
 
         long long result;
-        if (tok->op == '*')
+        if (tok->op == '*') {
             result = (stringToLL(tok->previous->str()) * stringToLL(tok->next->str()));
+        }
         else if (tok->op == '/' || tok->op == '%') {
             const long long rhs = stringToLL(tok->next->str());
             if (rhs == 0)
@@ -1157,8 +1217,9 @@ void simplecpp::TokenList::constFoldMulDivRem(Token *tok)
                 result = (lhs / rhs);
             else
                 result = (lhs % rhs);
-        } else
+        } else {
             continue;
+        }
 
         tok = tok->previous;
         tok->setstr(toString(result));
@@ -1250,8 +1311,6 @@ void simplecpp::TokenList::constFoldComparison(Token *tok)
     }
 }
 
-static const std::string BITAND("bitand");
-static const std::string BITOR("bitor");
 static const std::string XOR("xor");
 void simplecpp::TokenList::constFoldBitwise(Token *tok)
 {
@@ -1286,7 +1345,6 @@ void simplecpp::TokenList::constFoldBitwise(Token *tok)
     }
 }
 
-static const std::string AND("and");
 static const std::string OR("or");
 void simplecpp::TokenList::constFoldLogicalOp(Token *tok)
 {
@@ -1317,10 +1375,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 +1394,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);
@@ -1381,8 +1440,9 @@ std::string simplecpp::TokenList::readUntil(Stream &stream, const Location &loca
                     ret.erase(ret.size()-1U);
                     backslash = (next == '\r');
                     update_ch = false;
-                } else if (next == '\\')
+                } else if (next == '\\') {
                     update_ch = !update_ch;
+                }
                 ret += next;
             } while (next == '\\');
             if (update_ch)
@@ -1393,11 +1453,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 +1466,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 +1482,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,10 +1496,16 @@ 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;
@@ -1472,8 +1513,11 @@ namespace simplecpp {
 
     class Macro {
     public:
-        explicit Macro(std::vector<std::string> &f) : nameTokDef(nullptr), valueToken(nullptr), endToken(nullptr), files(f), tokenListDefine(f), variadic(false), variadicOpt(false), optExpandValue(nullptr), optNoExpandValue(nullptr), 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");
@@ -1490,6 +1534,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());
@@ -1499,7 +1546,12 @@ 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() {
@@ -1511,8 +1563,9 @@ namespace simplecpp {
             if (this != &other) {
                 files = other.files;
                 valueDefinedInCode_ = other.valueDefinedInCode_;
-                if (other.tokenListDefine.empty())
+                if (other.tokenListDefine.empty()) {
                     parseDefine(other.nameTokDef);
+                }
                 else {
                     tokenListDefine = other.tokenListDefine;
                     parseDefine(tokenListDefine.cfront());
@@ -1533,9 +1586,11 @@ 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 {
@@ -1566,10 +1621,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;
@@ -1579,15 +1634,17 @@ namespace simplecpp {
                         if (par==0)
                             break;
                         --par;
-                    } else if (macro2tok->op == ')')
+                    } else if (macro2tok->op == ')') {
                         ++par;
+                    }
                     macro2tok = macro2tok->previous;
                 }
                 if (macro2tok) { // macro2tok->op == '('
                     macro2tok = macro2tok->previous;
                     expandedmacros.insert(name());
-                } else if (rawtok->op == '(')
+                } else if (rawtok->op == '(') {
                     macro2tok = output2.back();
+                }
                 if (!macro2tok || !macro2tok->name)
                     break;
                 if (output2.cfront() != output2.cback() && macro2tok->str() == this->name())
@@ -1607,8 +1664,9 @@ namespace simplecpp {
                 const Token *rawtok2 = rawtok;
                 for (; rawtok2; rawtok2 = rawtok2->next) {
                     rawtokens2.push_back(new Token(rawtok2->str(), loc));
-                    if (rawtok2->op == '(')
+                    if (rawtok2->op == '(') {
                         ++par;
+                    }
                     else if (rawtok2->op == ')') {
                         if (par <= 1U)
                             break;
@@ -1617,11 +1675,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;
         }
 
@@ -1667,28 +1725,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)
@@ -1696,11 +1754,16 @@ namespace simplecpp {
             return tok;
         }
 
+        /**
+         * @throws Error thrown in case of __VA_OPT__ issues
+         */
         bool parseDefine(const Token *nametoken) {
             nameTokDef = nametoken;
             variadic = false;
             variadicOpt = false;
+            delete optExpandValue;
             optExpandValue = nullptr;
+            delete optNoExpandValue;
             optNoExpandValue = nullptr;
             if (!nameTokDef) {
                 valueToken = endToken = nullptr;
@@ -1717,12 +1780,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)) {
@@ -1797,27 +1860,29 @@ 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 == '(')
+                if (tok->op == '(') {
                     ++par;
+                }
                 else if (tok->op == ')') {
                     if (par == 0U) {
-                        parametertokens.push_back(tok);
+                        parametertokens.emplace_back(tok);
                         break;
                     }
                     --par;
-                } else if (par == 0U && tok->op == ',' && (!variadic || parametertokens.size() < args.size()))
-                    parametertokens.push_back(tok);
+                } else if (par == 0U && tok->op == ',' && (!variadic || parametertokens.size() < args.size())) {
+                    parametertokens.emplace_back(tok);
+                }
             }
             return parametertokens;
         }
 
-        const Token *appendTokens(TokenList *tokens,
+        const Token *appendTokens(TokenList &tokens,
                                   const Location &rawloc,
                                   const Token * const lpar,
                                   const MacroMap &macros,
@@ -1835,13 +1900,14 @@ namespace simplecpp {
                     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 == '(')
+                    if (tok->op == '(') {
                         ++par;
+                    }
                     else if (tok->op == ')') {
                         --par;
                         if (par == 0U)
@@ -1850,30 +1916,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());
 
 #ifdef SIMPLECPP_DEBUG_MACRO_EXPANSION
             std::cout << "  expand " << name() << " " << locstring(defineLocation()) << std::endl;
 #endif
 
-            usageList.push_back(loc);
+            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;
             }
 
@@ -1885,7 +1951,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;
                 }
 
@@ -1914,19 +1980,20 @@ namespace simplecpp {
 
                 const MacroMap::const_iterator m = macros.find("__COUNTER__");
 
-                if (!counter || m == macros.end())
+                if (!counter || m == macros.end()) {
                     parametertokens2.swap(parametertokens1);
+                }
                 else {
                     const Macro &counterMacro = m->second;
                     unsigned int par = 0;
                     for (const Token *tok = parametertokens1[0]; tok && par < parametertokens1.size(); tok = tok->next) {
                         if (tok->str() == "__COUNTER__") {
                             tokensparams.push_back(new Token(toString(counterMacro.usageList.size()), tok->location));
-                            counterMacro.usageList.push_back(tok->location);
+                            counterMacro.usageList.emplace_back(tok->location);
                         } else {
                             tokensparams.push_back(new Token(*tok));
                             if (tok == parametertokens1[par]) {
-                                parametertokens2.push_back(tokensparams.cback());
+                                parametertokens2.emplace_back(tokensparams.cback());
                                 par++;
                             }
                         }
@@ -1934,7 +2001,8 @@ 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;
@@ -1959,20 +2027,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);
@@ -1988,20 +2056,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 == endToken2) {
-                    output->push_back(new Token(*tok->previous));
+                    if (tok) {
+                        output.push_back(new Token(*tok->previous));
+                    }
+                    else {
+                        output.push_back(new Token(*nameTokInst));
+                        output.back()->setstr("\"\"");
+                    }
                     break;
                 }
                 if (tok->op == '#') {
@@ -2014,7 +2088,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();
                 }
             }
@@ -2025,55 +2099,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 (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);
                 }
             }
@@ -2087,29 +2161,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)) {
-                    output->push_back(newMacroToken(tok->str(), loc, true, tok));
+                    output.push_back(newMacroToken(tok->str(), loc, true, tok));
                     return tok->next;
                 }
                 TokenList tokens(files);
                 tokens.push_back(new Token(*tok));
                 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)) {
+                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);
+                calledMacro.expand(temp, loc, tokens.cfront(), macros, expandedmacros);
                 return recursiveExpandToken(output, temp, loc, tok2, macros, expandedmacros, parametertokens);
             }
 
@@ -2129,25 +2204,27 @@ 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))
+                        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));
+            if (it != macros.end())
+                output.back()->markExpandedFrom(&it->second);
             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;
 
@@ -2160,12 +2237,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());
@@ -2178,15 +2255,15 @@ namespace simplecpp {
                 if (it != macros.end() && !partok->isExpandedFrom(&it->second) && (partok->str() == name() || expandedmacros.find(partok->str()) == expandedmacros.end())) {
                     std::set<TokenString> expandedmacros2(expandedmacros); // temporary amnesia to allow reexpansion of currently expanding macros during argument evaluation
                     expandedmacros2.erase(name());
-                    partok = it->second.expand(output, loc, partok, macros, expandedmacros2);
+                    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;
         }
 
@@ -2199,10 +2276,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) {
@@ -2212,7 +2289,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;
         }
 
@@ -2228,18 +2305,18 @@ namespace simplecpp {
          * @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, bool expandResult=true) 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))
                 throw invalidHashHash::unexpectedNewline(tok->location, name());
 
             const bool canBeConcatenatedWithEqual = A->isOneOf("+-*/%&|^") || A->str() == "<<" || A->str() == ">>";
-            const bool canBeConcatenatedStringOrChar = isStringLiteral_(A->str()) || isCharLiteral_(A->str());
+            const bool canBeConcatenatedStringOrChar = isStringLiteral(A->str()) || isCharLiteral(A->str());
             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);
 
@@ -2260,26 +2337,29 @@ namespace simplecpp {
 
                 // 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 (tokensB.empty())
+                if (expandArg(tokensB, B, parametertokens)) {
+                    if (tokensB.empty()) {
                         strAB = A->str();
-                    else if (varargs && A->op == ',')
+                    }
+                    else if (varargs && A->op == ',') {
                         strAB = ",";
-                    else if (varargs && unexpectedA)
+                    }
+                    else if (varargs && unexpectedA) {
                         throw invalidHashHash::unexpectedToken(tok->location, name(), A);
+                    }
                     else {
                         strAB = A->str() + tokensB.cfront()->str();
                         tokensB.deleteToken(tokensB.front());
@@ -2298,28 +2378,29 @@ namespace simplecpp {
                         throw invalidHashHash::universalCharacterUB(tok->location, name(), A, strAB);
                 }
 
-                if (varargs && tokensB.empty() && tok->previous->str() == ",")
-                    output->deleteToken(A);
+                if (varargs && tokensB.empty() && tok->previous->str() == ",") {
+                    output.deleteToken(A);
+                }
                 else if (strAB != "," && macros.find(strAB) == macros.end()) {
                     A->setstr(strAB);
                     for (Token *b = tokensB.front(); b; b = b->next)
                         b->location = loc;
-                    output->takeTokens(tokensB);
+                    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;
                         }
@@ -2327,10 +2408,10 @@ namespace simplecpp {
                     if (expandResult)
                         expandToken(output, loc, tokens.cfront(), macros, expandedmacros, parametertokens);
                     else
-                        output->takeTokens(tokens);
+                        output.takeTokens(tokens);
                     for (Token *b = tokensB.front(); b; b = b->next)
                         b->location = loc;
-                    output->takeTokens(tokensB);
+                    output.takeTokens(tokensB);
                 }
             }
 
@@ -2339,11 +2420,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 */
@@ -2374,8 +2455,8 @@ namespace simplecpp {
         bool variadicOpt;
 
         /** Expansion value for varadic macros with __VA_OPT__ expanded and discarded respectively */
-        const TokenList *optExpandValue;
-        const TokenList *optNoExpandValue;
+        const TokenList *optExpandValue{};
+        const TokenList *optNoExpandValue{};
 
         /** was the value of this macro actually defined in the code? */
         bool valueDefinedInCode_;
@@ -2385,12 +2466,17 @@ namespace simplecpp {
 namespace simplecpp {
 
 #ifdef __CYGWIN__
+    static bool startsWith(const std::string &s, const std::string &p)
+    {
+        return (s.size() >= p.size()) && std::equal(p.begin(), p.end(), s.begin());
+    }
+
     std::string convertCygwinToWindowsPath(const std::string &cygwinPath)
     {
         std::string windowsPath;
 
         std::string::size_type pos = 0;
-        if (cygwinPath.size() >= 11 && startsWith_(cygwinPath, "/cygdrive/")) {
+        if (cygwinPath.size() >= 11 && startsWith(cygwinPath, "/cygdrive/")) {
             const unsigned char driveLetter = cygwinPath[10];
             if (std::isalpha(driveLetter)) {
                 if (cygwinPath.size() == 11) {
@@ -2415,21 +2501,26 @@ namespace simplecpp {
         return windowsPath;
     }
 #endif
-}
 
+    bool isAbsolutePath(const std::string &path)
+    {
 #ifdef SIMPLECPP_WINDOWS
-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] == '\\');
-}
+        // C:\\path\\file
+        // C:/path/file
+        if (path.length() >= 3 && std::isalpha(path[0]) && path[1] == ':' && (path[2] == '\\' || path[2] == '/'))
+            return true;
+
+        // \\host\path\file
+        // //host/path/file
+        if (path.length() >= 2 && (path[0] == '\\' || path[0] == '/') && (path[1] == '\\' || path[1] == '/'))
+            return true;
+
+        return false;
 #else
-static bool isAbsolutePath(const std::string &path)
-{
-    return path.length() > 1U && path[0] == '/';
-}
+        return !path.empty() && path[0] == '/';
 #endif
+    }
+}
 
 namespace simplecpp {
     /**
@@ -2506,17 +2597,19 @@ namespace simplecpp {
     }
 }
 
-/** 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");
         }
@@ -2531,7 +2624,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)
@@ -2556,7 +2649,7 @@ static void simplifySizeof(simplecpp::TokenList &expr, const std::map<std::strin
 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)
@@ -2574,6 +2667,10 @@ static std::string dirPath(const std::string& path, bool withTrailingSlash=true)
 }
 
 static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader);
+
+/** Evaluate __has_include(include)
+ * @throws std::runtime_error thrown on missing arguments or invalid expression
+ */
 static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI &dui)
 {
     if (!isCpp17OrLater(dui) && !isGnu(dui))
@@ -2582,11 +2679,11 @@ static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI
     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");
         }
@@ -2600,11 +2697,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");
             }
@@ -2615,7 +2712,7 @@ 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();
         } else {
             header = tok1->str().substr(1U, tok1->str().size() - 2U);
@@ -2630,12 +2727,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") {
@@ -2659,7 +2758,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,
@@ -2667,7 +2766,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();
@@ -2679,34 +2778,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
@@ -2727,8 +2798,9 @@ long long simplecpp::characterLiteralToLL(const std::string& str)
         pos = 3;
     } else if (str.size() >= 2 && (str[0] == 'L' || str[0] == 'U') && str[1] == '\'') {
         pos = 2;
-    } else
+    } else {
         throw std::runtime_error("expected a character literal");
+    }
 
     unsigned long long multivalue = 0;
 
@@ -2900,6 +2972,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) {
@@ -2922,6 +2997,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);
@@ -2990,7 +3070,7 @@ static std::string openHeaderDirect(std::ifstream &f, const std::string &path)
 
 static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader)
 {
-    if (isAbsolutePath(header))
+    if (simplecpp::isAbsolutePath(header))
         return openHeaderDirect(f, simplecpp::simplifyPath(header));
 
     // prefer first to search the header relatively to source file if found, when not a system header
@@ -3024,8 +3104,7 @@ std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::tryload(FileDat
         return {id_it->second, false};
     }
 
-    std::ifstream f(path);
-    FileData *const data = new FileData {path, TokenList(f, filenames, path, outputList)};
+    auto *const data = new FileData {path, TokenList(path, filenames, outputList)};
 
     if (dui.removeComments)
         data->tokens.removeComments();
@@ -3085,13 +3164,27 @@ std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get(const std::
 
 bool simplecpp::FileDataCache::getFileId(const std::string &path, FileID &id)
 {
-#ifdef SIMPLECPP_WINDOWS
-    HANDLE hFile = CreateFileA(path.c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+#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;
 
-    const BOOL ret = GetFileInformationByHandleEx(hFile, FileIdInfo, &id.fileIdInfo, sizeof(id.fileIdInfo));
+    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);
 
@@ -3119,7 +3212,7 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,
     std::list<const Token *> filelist;
 
     // -include files
-    for (std::list<std::string>::const_iterator it = dui.includes.begin(); it != dui.includes.end(); ++it) {
+    for (auto it = dui.includes.cbegin(); it != dui.includes.cend(); ++it) {
         const std::string &filename = *it;
 
         const auto loadResult = cache.get("", filename, dui, false, filenames, outputList);
@@ -3128,11 +3221,12 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,
 
         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;
         }
@@ -3146,7 +3240,7 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,
         if (dui.removeComments)
             filedata->tokens.removeComments();
 
-        filelist.push_back(filedata->tokens.front());
+        filelist.emplace_back(filedata->tokens.front());
     }
 
     for (const Token *rawtok = rawtokens.cfront(); rawtok || !filelist.empty(); rawtok = rawtok ? rawtok->next : nullptr) {
@@ -3162,7 +3256,7 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,
         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))
@@ -3185,27 +3279,28 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,
         if (dui.removeComments)
             filedata->tokens.removeComments();
 
-        filelist.push_back(filedata->tokens.front());
+        filelist.emplace_back(filedata->tokens.front());
     }
 
     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;
         }
@@ -3213,7 +3308,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;
 }
@@ -3279,7 +3374,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     const bool hasInclude = isCpp17OrLater(dui) || isGnu(dui);
     MacroMap macros;
     bool strictAnsiDefined = false;
-    for (std::list<std::string>::const_iterator it = dui.defines.begin(); it != dui.defines.end(); ++it) {
+    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('(');
@@ -3290,8 +3385,32 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
             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;
+        } catch (const simplecpp::Macro::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();
@@ -3301,7 +3420,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     macros.insert(std::make_pair("__FILE__", Macro("__FILE__", "__FILE__", dummy)));
     macros.insert(std::make_pair("__LINE__", Macro("__LINE__", "__LINE__", dummy)));
     macros.insert(std::make_pair("__COUNTER__", Macro("__COUNTER__", "__COUNTER__", dummy)));
-    struct tm ltime = {};
+    struct tm ltime {};
     getLocaltime(ltime);
     macros.insert(std::make_pair("__DATE__", Macro("__DATE__", getDateDefine(&ltime), dummy)));
     macros.insert(std::make_pair("__TIME__", Macro("__TIME__", getTimeDefine(&ltime), dummy)));
@@ -3316,10 +3435,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;
@@ -3333,7 +3454,7 @@ 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);
@@ -3343,13 +3464,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) {
+    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) {
@@ -3371,11 +3492,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;
@@ -3383,16 +3505,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();
@@ -3412,23 +3538,25 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                         else
                             it->second = macro;
                     }
-                } catch (const std::runtime_error &) {
+                } catch (const std::runtime_error &err) {
                     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 out{
+                            Output::SYNTAX_ERROR,
+                            rawtok->location,
+                            std::string("Failed to parse #define, ") + err.what()
+                        };
+                        outputList->emplace_back(std::move(out));
                     }
                     output.clear();
                     return;
-                } catch (simplecpp::Macro::Error &err) {
+                } 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 parse #define, " + err.what;
-                        outputList->push_back(out);
+                        simplecpp::Output out{
+                            simplecpp::Output::SYNTAX_ERROR,
+                            err.location,
+                            "Failed to parse #define, " + err.what
+                        };
+                        outputList->emplace_back(std::move(out));
                     }
                     output.clear();
                     return;
@@ -3442,7 +3570,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;
                     }
@@ -3464,11 +3592,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;
@@ -3478,22 +3607,24 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
 
                 const bool systemheader = (inctok->str()[0] == '<');
                 const std::string header(inctok->str().substr(1U, inctok->str().size() - 2U));
-                const FileData *const filedata = cache.get(rawtok->location.file(), header, dui, systemheader, files, outputList).first;
+                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(filedata->filename) == pragmaOnce.end()) {
                     includetokenstack.push(gotoNextLine(rawtok));
@@ -3503,25 +3634,27 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
             } else if (rawtok->str() == IF || rawtok->str() == IFDEF || rawtok->str() == IFNDEF || rawtok->str() == ELIF) {
                 if (!sameline(rawtok,rawtok->next)) {
                     if (outputList) {
-                        simplecpp::Output out(files);
-                        out.type = Output::SYNTAX_ERROR;
-                        out.location = rawtok->location;
-                        out.msg = "Syntax error in #" + rawtok->str();
-                        outputList->push_back(out);
+                        simplecpp::Output out{
+                            simplecpp::Output::SYNTAX_ERROR,
+                            rawtok->location,
+                            "Syntax error in #" + rawtok->str()
+                        };
+                        outputList->emplace_back(std::move(out));
                     }
                     output.clear();
                     return;
                 }
 
                 bool conditionIsTrue;
-                if (ifstates.top() == AlwaysFalse || (ifstates.top() == ElseIsTrue && rawtok->str() != ELIF))
+                if (ifstates.top() == AlwaysFalse || (ifstates.top() == ElseIsTrue && rawtok->str() != ELIF)) {
                     conditionIsTrue = false;
+                }
                 else if (rawtok->str() == IFDEF) {
                     conditionIsTrue = (macros.find(rawtok->next->str()) != macros.end() || (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) {
@@ -3535,7 +3668,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));
@@ -3548,11 +3681,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;
@@ -3567,8 +3701,8 @@ 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 bool systemheader = (tok && tok->op == '<');
+                                const std::string &sourcefile = rawtokens.file(rawtok->location);
+                                const bool systemheader = tok->op == '<';
                                 std::string header;
 
                                 if (systemheader) {
@@ -3580,19 +3714,22 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                                     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;
@@ -3600,10 +3737,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;
                         }
@@ -3618,20 +3755,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;
@@ -3645,12 +3784,11 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                     else
                         ifstates.push(conditionIsTrue ? True : ElseIsTrue);
                     iftokens.push(rawtok);
-                } else if (ifstates.top() == True) {
-                    ifstates.top() = AlwaysFalse;
-                    iftokens.top()->nextcond = rawtok;
-                    iftokens.top() = rawtok;
-                } else if (ifstates.top() == ElseIsTrue && conditionIsTrue) {
-                    ifstates.top() = True;
+                } else {
+                    if (ifstates.top() == True)
+                        ifstates.top() = AlwaysFalse;
+                    else if (ifstates.top() == ElseIsTrue && conditionIsTrue)
+                        ifstates.top() = True;
                     iftokens.top()->nextcond = rawtok;
                     iftokens.top() = rawtok;
                 }
@@ -3671,7 +3809,7 @@ 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));
             }
             if (ifstates.top() != True && rawtok->nextcond)
                 rawtok = rawtok->nextcond->previous;
@@ -3700,7 +3838,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;
         }
@@ -3727,11 +3865,11 @@ 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));
             }
         }
     }
@@ -3746,14 +3884,16 @@ 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;
 }
 
@@ -3775,6 +3915,10 @@ std::string simplecpp::getCStdString(cstd_t std)
         // 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 "";
     }
@@ -3826,7 +3970,7 @@ std::string simplecpp::getCppStdString(cppstd_t std)
         // Clang 17, 18 return "202302L"
         return "202302L";
     case CPP26:
-        // supported by Clang 17+
+        // supported by GCC 14+ and Clang 17+
         return "202400L";
     case CPPUnknown:
         return "";
diff --git a/simplecpp.h b/simplecpp.h
index 8268fa8d..f29166ff 100644
--- a/simplecpp.h
+++ b/simplecpp.h
@@ -6,11 +6,8 @@
 #ifndef simplecppH
 #define simplecppH
 
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
-#  define SIMPLECPP_WINDOWS
-#endif
-
 #include <cctype>
+#include <cstdint>
 #include <cstring>
 #include <iosfwd>
 #include <list>
@@ -19,7 +16,18 @@
 #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
@@ -33,10 +41,8 @@
 #  define SIMPLECPP_LIB
 #endif
 
-#ifdef SIMPLECPP_WINDOWS
-#  include <cstdint>
-#else
-#  include <sys/stat.h>
+#ifndef _WIN32
+#  include <sys/types.h>
 #endif
 
 #if defined(_MSC_VER)
@@ -46,34 +52,80 @@
 #  pragma warning(disable : 4244)
 #endif
 
+// provide legacy (i.e. raw pointer) API for TokenList
+// note: std::istream has an overhead compared to raw pointers
+#ifndef SIMPLECPP_TOKENLIST_ALLOW_PTR
+// still provide the legacy API in case we lack the performant wrappers
+#  if !defined(__cpp_lib_string_view) && !defined(__cpp_lib_span)
+#    define SIMPLECPP_TOKENLIST_ALLOW_PTR 1
+#  else
+#    define SIMPLECPP_TOKENLIST_ALLOW_PTR 0
+#  endif
+#endif
+
 namespace simplecpp {
     /** C code standard */
-    enum cstd_t { 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 initialization 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;
-    class FileDataCache;
 
     /**
      * 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) {}
-
-        Location(const Location &loc) : files(loc.files), fileIndex(loc.fileIndex), line(loc.line), col(loc.col) {}
+    struct SIMPLECPP_LIB Location {
+        Location() = default;
+        Location(unsigned int fileIndex, unsigned int line, unsigned int col)
+            : fileIndex(fileIndex)
+            , line(line)
+            , col(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);
@@ -90,16 +142,9 @@ namespace simplecpp {
             return fileIndex == other.fileIndex && line == other.line;
         }
 
-        const std::string& file() const {
-            return fileIndex < files.size() ? files[fileIndex] : emptyFileName;
-        }
-
-        const std::vector<std::string> &files;
-        unsigned int fileIndex;
-        unsigned int line;
-        unsigned int col;
-    private:
-        static const std::string emptyFileName;
+        unsigned int fileIndex{};
+        unsigned int line{};
+        unsigned int col{};
     };
 
     /**
@@ -109,21 +154,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), nextcond(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), nextcond(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;
@@ -136,9 +174,9 @@ namespace simplecpp {
         bool isOneOf(const char ops[]) const;
         bool startsWithOneOf(const char c[]) const;
         bool endsWithOneOf(const char c[]) const;
-        static bool isNumberLike(const std::string& str) {
-            return std::isdigit(static_cast<unsigned char>(str[0])) ||
-                   (str.size() > 1U && (str[0] == '-' || str[0] == '+') && std::isdigit(static_cast<unsigned char>(str[1])));
+        static bool isNumberLike(const std::string& s) {
+            return std::isdigit(static_cast<unsigned char>(s[0])) ||
+                   (s.size() > 1U && (s[0] == '-' || s[0] == '+') && std::isdigit(static_cast<unsigned char>(s[1])));
         }
 
         TokenString macro;
@@ -148,9 +186,9 @@ namespace simplecpp {
         bool number;
         bool whitespaceahead;
         Location location;
-        Token *previous;
-        Token *next;
-        mutable const Token *nextcond;
+        Token *previous{};
+        Token *next{};
+        mutable const Token *nextcond{};
 
         const Token *previousSkipComments() const {
             const Token *tok = this->previous;
@@ -175,22 +213,29 @@ namespace simplecpp {
         bool isExpandedFrom(const Macro* m) const {
             return mExpandedFrom.find(m) != mExpandedFrom.end();
         }
+        void markExpandedFrom(const Macro* m) {
+            mExpandedFrom.insert(m);
+        }
 
         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,
@@ -202,12 +247,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 {
@@ -218,9 +263,41 @@ 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 */
-        TokenList(const 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 unsigned char (&data)[size], std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(data, size-1, filenames, filename, outputList, 0)
+        {}
+#if SIMPLECPP_TOKENLIST_ALLOW_PTR
+        /** generates a token list from the given buffer */
+        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(data, size, filenames, filename, outputList, 0)
+        {}
+        /** generates a token list from the given buffer */
+        TokenList(const char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data), size, filenames, filename, outputList, 0)
+        {}
+#endif // SIMPLECPP_TOKENLIST_ALLOW_PTR
+        /** generates a token list from the given buffer */
+        TokenList(View data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, outputList, 0)
+        {}
+#ifdef __cpp_lib_span
+        /** generates a token list from the given buffer */
+        TokenList(std::span<const char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, outputList, 0)
+        {}
+
+        /** generates a token list from the given buffer */
+        TokenList(std::span<const unsigned char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(data.data(), data.size(), filenames, filename, outputList, 0)
+        {}
+#endif // __cpp_lib_span
+
         /** generates a token list from the given filename parameter */
         TokenList(const std::string &filename, std::vector<std::string> &filenames, OutputList *outputList = nullptr);
         TokenList(const TokenList &other);
@@ -235,10 +312,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();
@@ -295,24 +376,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);
 
@@ -323,11 +413,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 */
@@ -343,14 +433,14 @@ 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 {
@@ -375,7 +465,8 @@ namespace simplecpp {
         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) {
-            FileData *const newdata = new FileData(std::move(data));
+            // NOLINTNEXTLINE(misc-const-correctness) - FP
+            auto *const newdata = new FileData(std::move(data));
 
             mData.emplace_back(newdata);
             mNameMap.emplace(newdata->filename, newdata);
@@ -387,10 +478,10 @@ namespace simplecpp {
             mData.clear();
         }
 
-        typedef std::vector<std::unique_ptr<FileData>> container_type;
-        typedef container_type::iterator iterator;
-        typedef container_type::const_iterator const_iterator;
-        typedef container_type::size_type size_type;
+        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();
@@ -416,7 +507,7 @@ namespace simplecpp {
 
     private:
         struct FileID {
-#ifdef SIMPLECPP_WINDOWS
+#ifdef _WIN32
             struct {
                 std::uint64_t VolumeSerialNumber;
                 struct {
@@ -440,7 +531,7 @@ namespace simplecpp {
 #endif
             struct Hasher {
                 std::size_t operator()(const FileID &id) const {
-#ifdef SIMPLECPP_WINDOWS
+#ifdef _WIN32
                     return static_cast<std::size_t>(id.fileIdInfo.FileId.IdentifierHi ^ id.fileIdInfo.FileId.IdentifierLo ^
                                                     id.fileIdInfo.VolumeSerialNumber);
 #else
@@ -462,6 +553,34 @@ namespace simplecpp {
         id_map_type mIdMap;
     };
 
+    /** Converts character literal (including prefix, but not ud-suffix) to long long value.
+     *
+     * Assumes ASCII-compatible single-byte encoded str for narrow literals
+     * and UTF-8 otherwise.
+     *
+     * For target assumes
+     * - execution character set encoding matching str
+     * - UTF-32 execution wide-character set encoding
+     * - requirements for __STDC_UTF_16__, __STDC_UTF_32__ and __STDC_ISO_10646__ satisfied
+     * - char16_t is 16bit wide
+     * - char32_t is 32bit wide
+     * - wchar_t is 32bit wide and unsigned
+     * - matching char signedness to host
+     * - matching sizeof(int) to host
+     *
+     * For host assumes
+     * - ASCII-compatible execution character set
+     *
+     * For host and target assumes
+     * - CHAR_BIT == 8
+     * - two's complement
+     *
+     * Implements multi-character narrow literals according to GCC's behavior,
+     * except multi code unit universal character names are not supported.
+     * Multi-character wide literals are not supported.
+     * Limited support of universal character names for non-UTF-8 execution character set encodings.
+     * @throws std::runtime_error thrown on invalid literal
+     */
     SIMPLECPP_LIB long long characterLiteralToLL(const std::string& str);
 
     SIMPLECPP_LIB FileDataCache load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = nullptr, FileDataCache cache = {});
@@ -504,10 +623,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
 
+#undef SIMPLECPP_LIB
+
 #endif
diff --git a/test.cpp b/test.cpp
index ccb653ca..6b034b43 100644
--- a/test.cpp
+++ b/test.cpp
@@ -6,23 +6,39 @@
 #include "simplecpp.h"
 
 #include <cctype>
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <exception>
 #include <iostream>
+#include <list>
 #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;
+
+namespace {
+    enum class Input : std::uint8_t {
+        Stringstream,
+        CharBuffer
+    };
+}
+
+static Input USE_INPUT = Input::Stringstream;
 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)
 {
@@ -35,12 +51,22 @@ static std::string pprint(const std::string &in)
     return ret;
 }
 
+static const char* inputString(Input input) {
+    switch (input) {
+    case Input::Stringstream:
+        return "Stringstream";
+    case Input::CharBuffer:
+        return "CharBuffer";
+    }
+    return ""; // unreachable - needed for GCC and Visual Studio
+}
+
 static int assertEquals(const std::string &expected, const std::string &actual, int line)
 {
     if (expected != actual) {
         numberOfFailedAssertions++;
-        std::cerr << "------ assertion failed ---------" << std::endl;
-        std::cerr << "line " << line << std::endl;
+        std::cerr << "------ assertion failed (" << inputString(USE_INPUT) << ")---------" << std::endl;
+        std::cerr << "line test.cpp:" << line << std::endl;
         std::cerr << "expected:" << pprint(expected) << std::endl;
         std::cerr << "actual:" << pprint(actual) << std::endl;
     }
@@ -62,8 +88,9 @@ static void assertThrowFailed(int line)
 
 static void testcase(const std::string &name, void (*f)(), int argc, char * const *argv)
 {
-    if (argc == 1)
+    if (argc == 1) {
         f();
+    }
     else {
         for (int i = 1; i < argc; i++) {
             if (name == argv[i])
@@ -76,8 +103,16 @@ 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);
+    switch (USE_INPUT) {
+    case Input::Stringstream: {
+        std::istringstream istr(std::string(code, size));
+        return {istr,filenames,filename,outputList};
+    }
+    case Input::CharBuffer:
+        return {{code, size}, filenames, filename, outputList};
+    }
+
+    return simplecpp::TokenList{filenames}; // unreachable - needed for GCC and Visual Studio
 }
 
 static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)
@@ -97,14 +132,15 @@ static std::string readfile(const char code[], std::size_t size, simplecpp::Outp
     return makeTokenList(code,size,files,std::string(),outputList).stringify();
 }
 
-static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList)
+static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage = nullptr, std::list<simplecpp::IfCond> *ifCond = nullptr, const std::string &file = std::string())
 {
     std::vector<std::string> files;
     simplecpp::FileDataCache cache;
-    simplecpp::TokenList tokens = makeTokenList(code,files);
-    tokens.removeComments();
+    simplecpp::TokenList tokens = makeTokenList(code,files, file);
+    if (dui.removeComments)
+        tokens.removeComments();
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, tokens, files, cache, dui, outputList);
+    simplecpp::preprocess(tokens2, tokens, files, cache, dui, outputList, macroUsage, ifCond);
     simplecpp::cleanup(cache);
     return tokens2.stringify();
 }
@@ -114,6 +150,11 @@ static std::string preprocess(const char code[])
     return preprocess(code, simplecpp::DUI(), nullptr);
 }
 
+static std::string preprocess(const char code[], const std::string &file)
+{
+    return preprocess(code, simplecpp::DUI(), nullptr, nullptr, nullptr, file);
+}
+
 static std::string preprocess(const char code[], const simplecpp::DUI &dui)
 {
     return preprocess(code, dui, nullptr);
@@ -124,6 +165,16 @@ static std::string preprocess(const char code[], simplecpp::OutputList *outputLi
     return preprocess(code, simplecpp::DUI(), outputList);
 }
 
+static std::string preprocess(const char code[], std::list<simplecpp::IfCond> *ifCond)
+{
+    return preprocess(code, simplecpp::DUI(), nullptr, nullptr, ifCond);
+}
+
+static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> *macroUsage)
+{
+    return preprocess(code, simplecpp::DUI(), nullptr, macroUsage);
+}
+
 static std::string toString(const simplecpp::OutputList &outputList)
 {
     std::ostringstream ostr;
@@ -187,7 +238,7 @@ static void backslash()
 
 static void builtin()
 {
-    ASSERT_EQUALS("\"\" 1 0", preprocess("__FILE__ __LINE__ __COUNTER__"));
+    ASSERT_EQUALS("\"test.c\" 1 0", preprocess("__FILE__ __LINE__ __COUNTER__", "test.c"));
     ASSERT_EQUALS("\n\n3", preprocess("\n\n__LINE__"));
     ASSERT_EQUALS("\n\n0", preprocess("\n\n__COUNTER__"));
     ASSERT_EQUALS("\n\n0 1", preprocess("\n\n__COUNTER__ __COUNTER__"));
@@ -250,10 +301,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
@@ -315,6 +366,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");
 
@@ -366,6 +419,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()
@@ -393,6 +473,7 @@ static void combineOperators_floatliteral()
     ASSERT_EQUALS("1p + 3", preprocess("1p+3"));
     ASSERT_EQUALS("1.0_a . b", preprocess("1.0_a.b"));
     ASSERT_EQUALS("1_a . b", preprocess("1_a.b"));
+    ASSERT_EQUALS("bool x = d != 0. and b ;", preprocess("bool x = d != 0. and b;"));
 }
 
 static void combineOperators_increment()
@@ -412,6 +493,7 @@ static void combineOperators_andequal()
     ASSERT_EQUALS("x &= 2 ;", preprocess("x &= 2;"));
     ASSERT_EQUALS("void f ( x & = 2 ) ;", preprocess("void f(x &= 2);"));
     ASSERT_EQUALS("f ( x &= 2 ) ;", preprocess("f(x &= 2);"));
+    ASSERT_EQUALS("f ( ) { return new int ( i &= 1 ) ; }", preprocess("f () { return new int(i &= 1); }"));
 }
 
 static void combineOperators_ellipsis()
@@ -432,33 +514,36 @@ 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));
+                         "}\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));
+                         "\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));
+    ASSERT_EQUALS("void f ( ) {", preprocess(code3, dui));
 
     const char code4[] = "void f() {// \\\\\\\t\t\n}\n";
-    ASSERT_EQUALS("void f ( ) {", preprocess(code4));
+    ASSERT_EQUALS("void f ( ) {", preprocess(code4, dui));
 
     const char code5[] = "void f() {// \\\\\\a\n}\n";
-    ASSERT_EQUALS("void f ( ) {\n}", preprocess(code5));
+    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));
+    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"));
@@ -565,9 +650,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
@@ -632,6 +720,181 @@ static void define13()
                   "}", preprocess(code));
 }
 
+static void define14() // #296
+{
+    const char code[] = "#define bar(x) x % 2\n"
+                        "#define foo(x) printf(#x \"\\n\")\n"
+                        "\n"
+                        " foo(bar(3));\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "printf ( \"bar(3)\" \"\\n\" ) ;", preprocess(code));
+}
+
+static void define15() // #231
+{
+    const char code[] = "#define CAT(a, b) CAT2(a, b)\n"
+                        "#define CAT2(a, b) a ## b\n"
+                        "#define FOO x\n"
+                        "#define BAR() CAT(F, OO)\n"
+                        "#define BAZ CAT(B, AR)()\n"
+                        "BAZ\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "x", preprocess(code));
+}
+
+static void define16() // #201
+{
+    const char code[] = "#define ALL_COLORS(warm_colors) \\\n"
+                        "  X(Blue) \\\n"
+                        "  X(Green) \\\n"
+                        "  X(Purple) \\\n"
+                        "  warm_colors\n"
+                        "\n"
+                        "#define WARM_COLORS \\\n"
+                        "  X(Red) \\\n"
+                        "  X(Yellow) \\\n"
+                        "  X(Orange)\n"
+                        "\n"
+                        "#define COLOR_SET ALL_COLORS(WARM_COLORS)\n"
+                        "\n"
+                        "#define X(color) #color,\n"
+                        "\n"
+                        "COLOR_SET\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\"Blue\" , \"Green\" , \"Purple\" , \"Red\" , \"Yellow\" , \"Orange\" ,", preprocess(code));
+}
+
+static void define17() // #185
+{
+    const char code[] = "#define at(x, y) x##y\n"
+                        "#define b(...) \\\n"
+                        "aa(__VA_ARGS__, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , \\\n"
+                        ", , , , , , , , 2)\n"
+                        "#define aa(c, d, a, b, e, f, g, h, ab, ac, i, ad, j, k, l, m, n, o, p, ae, q, \\\n"
+                        "r, s, t, u, v, w, x, y, z, af, ag, ah, ai, aj, ak, al, am, an, ao, \\\n"
+                        "ap) \\\n"
+                        "ap\n"
+                        "#define aq(...) ar(b(__VA_ARGS__), __VA_ARGS__) static_assert(true, \" \")\n"
+                        "#define ar(ap, ...) at(I_, ap)(__VA_ARGS__)\n"
+                        "#define I_2(as, a)\n"
+                        "aq(a, array);\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "static_assert ( true , \" \" ) ;", preprocess(code));
+}
+
+static void define18() // #130
+{
+    const char code[] = "#define MAC2STR(x) x[0],x[1],x[2],x[3],x[4],x[5]\n"
+                        "#define FT_DEBUG(fmt, args...) if(pGlobalCtx && pGlobalCtx->debug_level>=2) printf(\"FT-dbg: \"fmt, ##args)\n"
+                        "\n"
+                        "FT_DEBUG(\"  %02x:%02x:%02x:%02x:%02x:%02x\\n\", MAC2STR(pCtx->wlan_intf_addr[i]));\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "if ( pGlobalCtx && pGlobalCtx -> debug_level >= 2 ) printf ( \"FT-dbg: \" \"  %02x:%02x:%02x:%02x:%02x:%02x\\n\" , pCtx -> wlan_intf_addr [ i ] [ 0 ] , pCtx -> wlan_intf_addr [ i ] [ 1 ] , pCtx -> wlan_intf_addr [ i ] [ 2 ] , pCtx -> wlan_intf_addr [ i ] [ 3 ] , pCtx -> wlan_intf_addr [ i ] [ 4 ] , pCtx -> wlan_intf_addr [ i ] [ 5 ] ) ;", preprocess(code));
+}
+
+static void define19() // #124
+{
+    const char code[] = "#define CONCAT(tok) tok##suffix\n"
+                        "\n"
+                        "CONCAT(Test);\n"
+                        "CONCAT(const Test);\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "Testsuffix ;\n"
+                  "const Testsuffix ;", preprocess(code));
+}
+
+static void define20() // #113
+{
+    const char code[] = "#define TARGS4 T1,T2,T3,T4\n"
+                        "#define FOOIMPL(T__CLASS, TARGS) void foo(const T__CLASS<TARGS>& x) { }\n"
+                        "#define FOOIMPL_4(T__CLASS)      FOOIMPL(T__CLASS, TARGS4)\n"
+                        "FOOIMPL_4(y)\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "void foo ( const y < T1 , T2 , T3 , T4 > & x ) { }", preprocess(code));
+}
+
+static void define21() // #66
+{
+    const char code[] = "#define GETMYID(a) ((a))+1\n"
+                        "#define FIGHT_FOO(c, ...) foo(c, ##__VA_ARGS__)\n"
+                        "FIGHT_FOO(1, GETMYID(a));\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "foo ( 1 , ( ( a ) ) + 1 ) ;", preprocess(code));
+}
+
+static void define22() // #40
+{
+    const char code[] = "#define COUNTER_NAME(NAME, ...) NAME##Count\n"
+                        "#define COMMA ,\n"
+                        "\n"
+                        "#define DECLARE_COUNTERS(LIST) unsigned long LIST(COUNTER_NAME, COMMA);\n"
+                        "\n"
+                        "#define ACTUAL_LIST(FUNCTION, SEPARATOR) \\\n"
+                        "FUNCTION(event1, int, foo) SEPARATOR \\\n"
+                        "FUNCTION(event2, char, bar)\n"
+                        "\n"
+                        "DECLARE_COUNTERS(ACTUAL_LIST)\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "unsigned long event1Count , event2Count ;", preprocess(code));
+}
+
+static void define23() // #40
+{
+    const char code[] = "#define COMMA ,\n"
+                        "#define MULTI(SEPARATOR) A SEPARATOR B\n"
+                        "\n"
+                        "#define VARS MULTI(COMMA)\n"
+                        "unsigned VARS;\n";
+    ASSERT_EQUALS("\n"
+                  "\n"
+                  "\n"
+                  "\n"
+                  "unsigned A , B ;", preprocess(code));
+}
 
 
 static void define_invalid_1()
@@ -639,7 +902,7 @@ static void define_invalid_1()
     const char code[] = "#define  A(\nB\n";
     simplecpp::OutputList outputList;
     ASSERT_EQUALS("", preprocess(code, &outputList));
-    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define\n", toString(outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, bad macro syntax\n", toString(outputList));
 }
 
 static void define_invalid_2()
@@ -647,7 +910,7 @@ static void define_invalid_2()
     const char code[] = "#define\nhas#";
     simplecpp::OutputList outputList;
     ASSERT_EQUALS("", preprocess(code, &outputList));
-    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define\n", toString(outputList));
+    ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, bad macro syntax\n", toString(outputList));
 }
 
 static void define_define_1()
@@ -887,6 +1150,16 @@ static void define_define_23() // #403 crash (infinite recursion)
     ASSERT_EQUALS("\n\n\n\nYdieZ ( void ) ;", preprocess(code));
 }
 
+static void define_define_24() // #590
+{
+    const char code[] = "#define B A\n"
+                        "#define A x(B)\n"
+                        "#define C(s) s\n"
+                        "#define D(s) C(s)\n"
+                        "D(A)\n";
+    ASSERT_EQUALS("\n\n\n\nx ( A )", preprocess(code));
+}
+
 static void define_va_args_1()
 {
     const char code[] = "#define A(fmt...) dostuff(fmt)\n"
@@ -1036,6 +1309,25 @@ static void define_va_opt_7()
                   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_va_opt_9()
+{
+    simplecpp::DUI dui;
+    dui.defines.emplace_back("f(...)=__VA_OPT__");
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("", preprocess("", dui, &outputList));
+    ASSERT_EQUALS("file0,0,dui_error,In definition of 'f': Missing opening parenthesis for __VA_OPT__\n", toString(outputList));
+}
+
 static void define_ifdef()
 {
     const char code[] = "#define A(X) X\n"
@@ -1065,6 +1357,15 @@ static void pragma_backslash()
     ASSERT_EQUALS("", preprocess(code, &outputList));
 }
 
+static void pragma_backslash_2() // #217
+{
+    const char code[] = "#pragma comment(linker, \"foo \\\n"
+                        "bar\")\n";
+
+    simplecpp::OutputList outputList;
+    ASSERT_EQUALS("", preprocess(code, &outputList));
+}
+
 static void dollar()
 {
     ASSERT_EQUALS("$ab", readfile("$ab"));
@@ -1123,6 +1424,43 @@ static void error5()
     ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));
 }
 
+static void error6()
+{
+    // "#error\<LF>"
+    const char code[] = "\xFF\xFE\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x5c\x00\x0a\x00";
+    std::vector<std::string> files;
+    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, cache, simplecpp::DUI(), &outputList);
+    ASSERT_EQUALS("file0,1,#error,#error \n", toString(outputList));
+}
+
+static void error7()
+{
+    const char code[] = "#error bla\\\nbla\n";
+    std::vector<std::string> files;
+    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, cache, simplecpp::DUI(), &outputList);
+    ASSERT_EQUALS("file0,1,#error,#error blabla\n", toString(outputList));
+}
+
+static void error8()
+{
+    const char code[] = "#error bla\\\r\nbla\n";
+    std::vector<std::string> files;
+    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, cache, simplecpp::DUI(), &outputList);
+    ASSERT_EQUALS("file0,1,#error,#error blabla\n", toString(outputList));
+}
+
 static void garbage()
 {
     simplecpp::OutputList outputList;
@@ -1556,11 +1894,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()
@@ -1573,9 +1914,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()
@@ -1588,13 +1935,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()
@@ -1607,9 +1965,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()
@@ -1622,9 +1985,14 @@ 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()
@@ -1637,9 +2005,12 @@ static void has_include_6()
                         "  #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));
-    ASSERT_EQUALS("", preprocess(code));
 }
 
 static void strict_ansi_1()
@@ -1680,7 +2051,7 @@ static void strict_ansi_4()
                         "#endif";
     simplecpp::DUI dui;
     dui.std = "gnu99";
-    dui.defines.push_back("__STRICT_ANSI__");
+    dui.defines.emplace_back("__STRICT_ANSI__");
     ASSERT_EQUALS("\nA", preprocess(code, dui));
 }
 
@@ -1727,7 +2098,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));
 }
 
@@ -1746,7 +2117,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));
 }
 
@@ -1757,7 +2128,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));
 }
 
@@ -1769,7 +2140,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));
 }
 
@@ -1781,7 +2152,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));
 }
 
@@ -1834,10 +2205,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));
 }
 
@@ -1960,7 +2331,7 @@ 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));
 }
 
@@ -2014,6 +2385,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";
@@ -2032,7 +2474,7 @@ static void missingHeader2()
     simplecpp::TokenList tokens2(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
+    dui.includePaths.emplace_back(".");
     simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
     ASSERT_EQUALS("", toString(outputList));
 }
@@ -2049,7 +2491,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));
 }
 
@@ -2064,7 +2508,7 @@ static void nestedInclude()
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
+    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));
@@ -2082,7 +2526,7 @@ static void systemInclude()
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back("include");
+    dui.includePaths.emplace_back("include");
     simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
 
     ASSERT_EQUALS("", toString(outputList));
@@ -2290,7 +2734,7 @@ 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;
@@ -2308,7 +2752,7 @@ static void include3()   // #16 - crash when expanding macro from header
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
+    dui.includePaths.emplace_back(".");
     simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n1234", out.stringify());
@@ -2317,7 +2761,7 @@ 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;
@@ -2335,8 +2779,8 @@ static void include4()   // #27 - -include
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
-    dui.includes.push_back("27.h");
+    dui.includePaths.emplace_back(".");
+    dui.includes.emplace_back("27.h");
     simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("123", out.stringify());
@@ -2362,7 +2806,7 @@ static void include5()    // #3 - handle #include MACRO
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
+    dui.includePaths.emplace_back(".");
     simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 1 \"3.h\"\n123", out.stringify());
@@ -2408,7 +2852,7 @@ static void include7()    // #include MACRO
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
+    dui.includePaths.emplace_back(".");
     simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 1 \"3.h\"\n123", out.stringify());
@@ -2446,7 +2890,7 @@ static void include9()
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
+    dui.includePaths.emplace_back(".");
     simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 2 \"1.h\"\nx = 1 ;", out.stringify());
@@ -2604,7 +3048,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()
@@ -2628,7 +3072,7 @@ static void stringify1()
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
-    dui.includePaths.push_back(".");
+    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());
@@ -2731,7 +3175,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));
 }
 
@@ -2973,6 +3417,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));
 }
@@ -2983,6 +3428,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));
 }
@@ -3076,7 +3522,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);
@@ -3169,6 +3615,230 @@ static void preprocess_files()
     }
 }
 
+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 ifCond()
+{
+    {
+        const char code[] = "int i;";
+        std::list<simplecpp::IfCond> ifCond;
+        ASSERT_EQUALS("int i ;", preprocess(code, &ifCond));
+        ASSERT_EQUALS(0, ifCond.size());
+    }
+    {
+        const char code[] = "#if 0\n"
+                            "# elif __GNUC__ == 1\n"
+                            "#  elif defined(__APPLE__)\n"
+                            "#endif\n";
+        std::list<simplecpp::IfCond> ifCond;
+        ASSERT_EQUALS("", preprocess(code, &ifCond));
+        ASSERT_EQUALS(3, ifCond.size());
+        auto it = ifCond.cbegin();
+        ASSERT_EQUALS(0, it->location.fileIndex);
+        ASSERT_EQUALS(1, it->location.line);
+        ASSERT_EQUALS(2, it->location.col);
+        ASSERT_EQUALS("0", it->E);
+        ASSERT_EQUALS(0, it->result);
+        ++it;
+        ASSERT_EQUALS(0, it->location.fileIndex);
+        ASSERT_EQUALS(2, it->location.line);
+        ASSERT_EQUALS(3, it->location.col);
+        ASSERT_EQUALS("__GNUC__ == 1", it->E);
+        ASSERT_EQUALS(0, it->result);
+        ++it;
+        ASSERT_EQUALS(0, it->location.fileIndex);
+        ASSERT_EQUALS(3, it->location.line);
+        ASSERT_EQUALS(4, it->location.col);
+        ASSERT_EQUALS("0", it->E);
+        ASSERT_EQUALS(0, it->result);
+    }
+}
+
+static void macroUsage()
+{
+    {
+        const char code[] = "int i;";
+        std::list<simplecpp::MacroUsage> macroUsage;
+        ASSERT_EQUALS("int i ;", preprocess(code, &macroUsage));
+        ASSERT_EQUALS(0, macroUsage.size());
+    }
+    {
+        const char code[] = "#define DEF_1\n"
+                            "#ifdef DEF_1\n"
+                            "#endif\n";
+        std::list<simplecpp::MacroUsage> macroUsage;
+        ASSERT_EQUALS("", preprocess(code, &macroUsage));
+        ASSERT_EQUALS(1, macroUsage.size());
+        auto it = macroUsage.cbegin();
+        ASSERT_EQUALS("DEF_1", it->macroName);
+        ASSERT_EQUALS(0, it->macroLocation.fileIndex);
+        ASSERT_EQUALS(1, it->macroLocation.line);
+        ASSERT_EQUALS(9, it->macroLocation.col);
+        ASSERT_EQUALS(true, it->macroValueKnown);
+        ASSERT_EQUALS(0, it->useLocation.fileIndex);
+        ASSERT_EQUALS(2, it->useLocation.line);
+        ASSERT_EQUALS(8, it->useLocation.col);
+    }
+}
+
+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()
 {
     {
@@ -3181,10 +3851,28 @@ static void fuzz_crash()
                             "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));
+    }
 }
 
-int main(int argc, char **argv)
+// 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());
+    }
+}
+
+static void runTests(int argc, char **argv, Input input)
+{
+    USE_INPUT = input;
+
     TEST_CASE(backslash);
 
     TEST_CASE(builtin);
@@ -3219,6 +3907,16 @@ int main(int argc, char **argv)
     TEST_CASE(define11);
     TEST_CASE(define12);
     TEST_CASE(define13);
+    TEST_CASE(define14); // #296
+    TEST_CASE(define15); // #231
+    TEST_CASE(define16); // #201
+    TEST_CASE(define17); // #185
+    TEST_CASE(define18); // #130
+    TEST_CASE(define19); // #124
+    TEST_CASE(define20); // #113
+    TEST_CASE(define21); // #66
+    TEST_CASE(define22); // #40
+    TEST_CASE(define23); // #40
     TEST_CASE(define_invalid_1);
     TEST_CASE(define_invalid_2);
     TEST_CASE(define_define_1);
@@ -3245,6 +3943,7 @@ int main(int argc, char **argv)
     TEST_CASE(define_define_21);
     TEST_CASE(define_define_22); // #400
     TEST_CASE(define_define_23); // #403 - crash, infinite recursion
+    TEST_CASE(define_define_24); // #590
     TEST_CASE(define_va_args_1);
     TEST_CASE(define_va_args_2);
     TEST_CASE(define_va_args_3);
@@ -3256,8 +3955,11 @@ int main(int argc, char **argv)
     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(define_va_opt_9); // #632
 
     TEST_CASE(pragma_backslash); // multiline pragma directive
+    TEST_CASE(pragma_backslash_2); // #217
 
     // UB: #ifdef as macro parameter
     TEST_CASE(define_ifdef);
@@ -3269,6 +3971,9 @@ int main(int argc, char **argv)
     TEST_CASE(error3);
     TEST_CASE(error4);
     TEST_CASE(error5);
+    TEST_CASE(error6);
+    TEST_CASE(error7);
+    TEST_CASE(error8);
 
     TEST_CASE(garbage);
     TEST_CASE(garbage_endif);
@@ -3351,6 +4056,12 @@ int main(int argc, char **argv)
     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);
@@ -3435,7 +4146,23 @@ int main(int argc, char **argv)
 
     TEST_CASE(preprocess_files);
 
+    TEST_CASE(tokenlist_api);
+
+    TEST_CASE(isAbsolutePath);
+
+    TEST_CASE(bad_macro_syntax);
+
+    TEST_CASE(ifCond);
+    TEST_CASE(macroUsage);
+
     TEST_CASE(fuzz_crash);
 
+    TEST_CASE(leak);
+}
+
+int main(int argc, char **argv)
+{
+    runTests(argc, argv, Input::Stringstream);
+    runTests(argc, argv, Input::CharBuffer);
     return numberOfFailedAssertions > 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 }