diff --git a/integration_test.py b/integration_test.py
index 27528e16..a59ae338 100644
--- a/integration_test.py
+++ b/integration_test.py
@@ -237,7 +237,13 @@ def test_same_name_header(record_property, tmpdir):
     assert stderr == ""
 
 def test_pragma_once_matching(record_property, tmpdir):
-    if platform.system() == "win32":
+    test_dir = os.path.join(tmpdir, "test_dir")
+    test_subdir = os.path.join(test_dir, "test_subdir")
+
+    test_file = os.path.join(test_dir, "test.c")
+    once_header = os.path.join(test_dir, "once.h")
+
+    if platform.system() == "Windows":
         names_to_test = [
             '"once.h"',
             '"Once.h"',
@@ -251,6 +257,10 @@ def test_pragma_once_matching(record_property, tmpdir):
             '"test_subdir/../Once.h"',
             '"Test_Subdir/../once.h"',
             '"Test_Subdir/../Once.h"',
+            f"\"{test_dir}/once.h\"",
+            f"\"{test_dir}/Once.h\"",
+            f"<{test_dir}/once.h>",
+            f"<{test_dir}/Once.h>",
         ]
     else:
         names_to_test = [
@@ -258,14 +268,10 @@ def test_pragma_once_matching(record_property, tmpdir):
             '<once.h>',
             '"../test_dir/once.h"',
             '"test_subdir/../once.h"',
+            f"\"{test_dir}/once.h\"",
+            f"<{test_dir}/once.h>",
         ]
 
-    test_dir = os.path.join(tmpdir, "test_dir")
-    test_subdir = os.path.join(test_dir, "test_subdir")
-
-    test_file = os.path.join(test_dir, "test.c")
-    once_header = os.path.join(test_dir, "once.h")
-
     os.mkdir(test_dir)
     os.mkdir(test_subdir)
 
diff --git a/main.cpp b/main.cpp
index 424ef6fa..a6d14386 100644
--- a/main.cpp
+++ b/main.cpp
@@ -9,7 +9,6 @@
 #include <cstring>
 #include <fstream>
 #include <iostream>
-#include <map>
 #include <string>
 #include <vector>
 
@@ -128,7 +127,7 @@ int main(int argc, char **argv)
     }
     rawtokens->removeComments();
     simplecpp::TokenList outputTokens(files);
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache filedata;
     simplecpp::preprocess(outputTokens, *rawtokens, files, filedata, dui, &outputList);
     simplecpp::cleanup(filedata);
     delete rawtokens;
diff --git a/simplecpp.cpp b/simplecpp.cpp
index c29040bc..a471190a 100755
--- a/simplecpp.cpp
+++ b/simplecpp.cpp
@@ -4,8 +4,10 @@
  */
 
 #if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
-#define SIMPLECPP_WINDOWS
-#define NOMINMAX
+#  define _WIN32_WINNT 0x0602
+#  define NOMINMAX
+#  include <windows.h>
+#  undef ERROR
 #endif
 
 #include "simplecpp.h"
@@ -32,21 +34,16 @@
 #include <stdexcept>
 #include <string>
 #ifdef SIMPLECPP_WINDOWS
-#include <mutex>
+#  include <mutex>
 #endif
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #ifdef _WIN32
-#include <direct.h>
+#  include <direct.h>
 #else
-#include <unistd.h>
-#endif
-
-#ifdef SIMPLECPP_WINDOWS
-#include <windows.h>
-#undef ERROR
+#  include <sys/stat.h>
 #endif
 
 static bool isHex(const std::string &s)
@@ -139,12 +136,6 @@ static unsigned long long stringToULL(const std::string &s)
     return ret;
 }
 
-// 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 startsWith_(const std::string &s, const std::string &p)
-{
-    return (s.size() >= p.size()) && std::equal(p.begin(), p.end(), s.begin());
-}
-
 static bool endsWith(const std::string &s, const std::string &e)
 {
     return (s.size() >= e.size()) && std::equal(e.rbegin(), e.rend(), s.rbegin());
@@ -435,7 +426,7 @@ class FileStream : public simplecpp::TokenList::Stream {
         lastStatus = lastCh = fgetc(file);
         return lastCh;
     }
-    virtual int peek() override{
+    virtual int peek() override {
         // keep lastCh intact
         const int ch = fgetc(file);
         unget_internal(ch);
@@ -2409,132 +2400,6 @@ namespace simplecpp {
 }
 
 #ifdef SIMPLECPP_WINDOWS
-
-using MyMutex = std::mutex;
-template<class T>
-using MyLock = std::lock_guard<T>;
-
-class RealFileNameMap {
-public:
-    RealFileNameMap() {}
-
-    bool getCacheEntry(const std::string& path, std::string& returnPath) {
-        MyLock<MyMutex> lock(m_mutex);
-
-        const std::map<std::string, std::string>::iterator it = m_fileMap.find(path);
-        if (it != m_fileMap.end()) {
-            returnPath = it->second;
-            return true;
-        }
-        return false;
-    }
-
-    void addToCache(const std::string& path, const std::string& actualPath) {
-        MyLock<MyMutex> lock(m_mutex);
-        m_fileMap[path] = actualPath;
-    }
-
-private:
-    std::map<std::string, std::string> m_fileMap;
-    MyMutex m_mutex;
-};
-
-static RealFileNameMap realFileNameMap;
-
-static bool realFileName(const std::string &f, std::string &result)
-{
-    // are there alpha characters in last subpath?
-    bool alpha = false;
-    for (std::string::size_type pos = 1; pos <= f.size(); ++pos) {
-        const unsigned char c = f[f.size() - pos];
-        if (c == '/' || c == '\\')
-            break;
-        if (std::isalpha(c)) {
-            alpha = true;
-            break;
-        }
-    }
-
-    // do not convert this path if there are no alpha characters (either pointless or cause wrong results for . and ..)
-    if (!alpha)
-        return false;
-
-    // Lookup filename or foldername on file system
-    if (!realFileNameMap.getCacheEntry(f, result)) {
-
-        WIN32_FIND_DATAA FindFileData;
-
-#ifdef __CYGWIN__
-        const std::string fConverted = simplecpp::convertCygwinToWindowsPath(f);
-        const HANDLE hFind = FindFirstFileExA(fConverted.c_str(), FindExInfoBasic, &FindFileData, FindExSearchNameMatch, NULL, 0);
-#else
-        HANDLE hFind = FindFirstFileExA(f.c_str(), FindExInfoBasic, &FindFileData, FindExSearchNameMatch, NULL, 0);
-#endif
-
-        if (INVALID_HANDLE_VALUE == hFind)
-            return false;
-        result = FindFileData.cFileName;
-        realFileNameMap.addToCache(f, result);
-        FindClose(hFind);
-    }
-    return true;
-}
-
-static RealFileNameMap realFilePathMap;
-
-/** Change case in given path to match filesystem */
-static std::string realFilename(const std::string &f)
-{
-    std::string ret;
-    ret.reserve(f.size()); // this will be the final size
-    if (realFilePathMap.getCacheEntry(f, ret))
-        return ret;
-
-    // Current subpath
-    std::string subpath;
-
-    for (std::string::size_type pos = 0; pos < f.size(); ++pos) {
-        const unsigned char c = f[pos];
-
-        // Separator.. add subpath and separator
-        if (c == '/' || c == '\\') {
-            // if subpath is empty just add separator
-            if (subpath.empty()) {
-                ret += c;
-                continue;
-            }
-
-            const bool isDriveSpecification =
-                (pos == 2 && subpath.size() == 2 && std::isalpha(subpath[0]) && subpath[1] == ':');
-
-            // Append real filename (proper case)
-            std::string f2;
-            if (!isDriveSpecification && realFileName(f.substr(0, pos), f2))
-                ret += f2;
-            else
-                ret += subpath;
-
-            subpath.clear();
-
-            // Append separator
-            ret += c;
-        } else {
-            subpath += c;
-        }
-    }
-
-    if (!subpath.empty()) {
-        std::string f2;
-        if (realFileName(f,f2))
-            ret += f2;
-        else
-            ret += subpath;
-    }
-
-    realFilePathMap.addToCache(f, ret);
-    return ret;
-}
-
 static bool isAbsolutePath(const std::string &path)
 {
     if (path.length() >= 3 && path[0] > 0 && std::isalpha(path[0]) && path[1] == ':' && (path[2] == '\\' || path[2] == '/'))
@@ -2542,8 +2407,6 @@ static bool isAbsolutePath(const std::string &path)
     return path.length() > 1U && (path[0] == '/' || path[0] == '\\');
 }
 #else
-#define realFilename(f)  f
-
 static bool isAbsolutePath(const std::string &path)
 {
     return path.length() > 1U && path[0] == '/';
@@ -2621,8 +2484,7 @@ namespace simplecpp {
         if (unc)
             path = '/' + path;
 
-        // cppcheck-suppress duplicateExpressionTernary - platform-dependent implementation
-        return strpbrk(path.c_str(), "*?") == nullptr ? realFilename(path) : path;
+        return path;
     }
 }
 
@@ -2681,37 +2543,8 @@ static bool isCpp17OrLater(const simplecpp::DUI &dui)
 }
 
 
-static std::string currentDirectoryOSCalc() {
-    const std::size_t size = 4096;
-    char currentPath[size];
-
-#ifndef _WIN32
-    if (getcwd(currentPath, size) != nullptr)
-#else
-    if (_getcwd(currentPath, size) != nullptr)
-#endif
-        return std::string(currentPath);
-
-    return "";
-}
-
-static const std::string& currentDirectory() {
-    static const std::string curdir = simplecpp::simplifyPath(currentDirectoryOSCalc());
-    return curdir;
-}
-
-static std::string toAbsolutePath(const std::string& path) {
-    if (path.empty()) {
-        return path;// preserve error file path that is indicated by an empty string
-    }
-    if (!isAbsolutePath(path)) {
-        return simplecpp::simplifyPath(currentDirectory() + "/" + path);
-    }
-    // otherwise
-    return simplecpp::simplifyPath(path);
-}
-
-static std::string dirPath(const std::string& path, bool withTrailingSlash=true) {
+static std::string dirPath(const std::string& path, bool withTrailingSlash=true)
+{
     const std::size_t lastSlash = path.find_last_of("\\/");
     if (lastSlash == std::string::npos) {
         return "";
@@ -2719,36 +2552,6 @@ static std::string dirPath(const std::string& path, bool withTrailingSlash=true)
     return path.substr(0, lastSlash + (withTrailingSlash ? 1U : 0U));
 }
 
-static std::string omitPathTrailingSlash(const std::string& path) {
-    if (endsWith(path, "/")) {
-        return path.substr(0, path.size() - 1U);
-    }
-    return path;
-}
-
-static std::string extractRelativePathFromAbsolute(const std::string& absoluteSimplifiedPath, const std::string& prefixSimplifiedAbsoluteDir = currentDirectory()) {
-    const std::string normalizedAbsolutePath = omitPathTrailingSlash(absoluteSimplifiedPath);
-    std::string currentPrefix = omitPathTrailingSlash(prefixSimplifiedAbsoluteDir);
-    std::string leadingParenting;
-    while (!startsWith_(normalizedAbsolutePath, currentPrefix)) {
-        leadingParenting = "../" + leadingParenting;
-        currentPrefix = dirPath(currentPrefix, false);
-    }
-    const std::size_t size = currentPrefix.size();
-    std::string relativeFromMeetingPath = normalizedAbsolutePath.substr(size, normalizedAbsolutePath.size() - size);
-    if (currentPrefix.empty() && !(startsWith_(absoluteSimplifiedPath, "/") && startsWith_(prefixSimplifiedAbsoluteDir, "/"))) {
-        // In the case that there is no common prefix path,
-        //  and at not both of the paths start with `/` (can happen only in Windows paths on distinct partitions),
-        //  return the absolute simplified path as is because no relative path can match.
-        return absoluteSimplifiedPath;
-    }
-    if (startsWith_(relativeFromMeetingPath, "/")) {
-        // omit the leading slash
-        relativeFromMeetingPath = relativeFromMeetingPath.substr(1, relativeFromMeetingPath.size());
-    }
-    return leadingParenting + relativeFromMeetingPath;
-}
-
 static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader);
 static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI &dui)
 {
@@ -2793,10 +2596,8 @@ static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI
 
             for (simplecpp::Token *headerToken = tok1->next; headerToken != tok3; headerToken = headerToken->next)
                 header += headerToken->str();
-            // cppcheck-suppress selfAssignment - platform-dependent implementation
-            header = realFilename(header);
         } else {
-            header = realFilename(tok1->str().substr(1U, tok1->str().size() - 2U));
+            header = tok1->str().substr(1U, tok1->str().size() - 2U);
         }
         std::ifstream f;
         const std::string header2 = openHeader(f,dui,sourcefile,header,systemheader);
@@ -3126,206 +2927,185 @@ class NonExistingFilesCache {
     NonExistingFilesCache() {}
 
     bool contains(const std::string& path) {
-        MyLock<MyMutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return (m_pathSet.find(path) != m_pathSet.end());
     }
 
     void add(const std::string& path) {
-        MyLock<MyMutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         m_pathSet.insert(path);
     }
 
     void clear() {
-        MyLock<MyMutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         m_pathSet.clear();
     }
 
 private:
     std::set<std::string> m_pathSet;
-    MyMutex m_mutex;
+    std::mutex m_mutex;
 };
 
 static NonExistingFilesCache nonExistingFilesCache;
 
 #endif
 
-static std::string openHeader(std::ifstream &f, const std::string &path)
+static std::string openHeaderDirect(std::ifstream &f, const std::string &path)
 {
-    std::string simplePath = simplecpp::simplifyPath(path);
 #ifdef SIMPLECPP_WINDOWS
-    if (nonExistingFilesCache.contains(simplePath))
+    if (nonExistingFilesCache.contains(path))
         return "";  // file is known not to exist, skip expensive file open call
 #endif
-    f.open(simplePath.c_str());
+    f.open(path.c_str());
     if (f.is_open())
-        return simplePath;
+        return path;
 #ifdef SIMPLECPP_WINDOWS
-    nonExistingFilesCache.add(simplePath);
+    nonExistingFilesCache.add(path);
 #endif
     return "";
 }
 
-static std::string getRelativeFileName(const std::string &baseFile, const std::string &header, bool returnAbsolutePath)
-{
-    const std::string baseFileSimplified = simplecpp::simplifyPath(baseFile);
-    const std::string baseFileAbsolute = isAbsolutePath(baseFileSimplified) ?
-        baseFileSimplified :
-        simplecpp::simplifyPath(currentDirectory() + "/" + baseFileSimplified);
-
-    const std::string headerSimplified = simplecpp::simplifyPath(header);
-    const std::string path = isAbsolutePath(headerSimplified) ?
-        headerSimplified :
-        simplecpp::simplifyPath(dirPath(baseFileAbsolute) + headerSimplified);
-
-    return returnAbsolutePath ? toAbsolutePath(path) : extractRelativePathFromAbsolute(path);
-}
-
-static std::string openHeaderRelative(std::ifstream &f, const std::string &sourcefile, const std::string &header)
-{
-    return openHeader(f, getRelativeFileName(sourcefile, header, isAbsolutePath(sourcefile)));
-}
-
-// returns the simplified header path:
-// * If the header path is absolute, returns it in absolute path
-// * Otherwise, returns it in relative path with respect to the current directory
-static std::string getIncludePathFileName(const std::string &includePath, const std::string &header)
+static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader)
 {
-    std::string simplifiedHeader = simplecpp::simplifyPath(header);
+    if (isAbsolutePath(header))
+        return openHeaderDirect(f, simplecpp::simplifyPath(header));
 
-    if (isAbsolutePath(simplifiedHeader)) {
-        return simplifiedHeader;
+    // prefer first to search the header relatively to source file if found, when not a system header
+    if (!systemheader) {
+        std::string path = openHeaderDirect(f, simplecpp::simplifyPath(dirPath(sourcefile) + header));
+        if (!path.empty()) {
+            return path;
+        }
     }
 
-    std::string basePath = toAbsolutePath(includePath);
-    if (!basePath.empty() && basePath[basePath.size()-1U]!='/' && basePath[basePath.size()-1U]!='\\')
-        basePath += '/';
-    const std::string absoluteSimplifiedHeaderPath = simplecpp::simplifyPath(basePath + simplifiedHeader);
-    // preserve absoluteness/relativieness of the including dir
-    return isAbsolutePath(includePath) ? absoluteSimplifiedHeaderPath : extractRelativePathFromAbsolute(absoluteSimplifiedHeaderPath);
-}
-
-static std::string openHeaderIncludePath(std::ifstream &f, const simplecpp::DUI &dui, const std::string &header)
-{
-    for (std::list<std::string>::const_iterator it = dui.includePaths.begin(); it != dui.includePaths.end(); ++it) {
-        std::string path = openHeader(f, getIncludePathFileName(*it, header));
+    // search the header on the include paths (provided by the flags "-I...")
+    for (const auto &includePath : dui.includePaths) {
+        std::string path = openHeaderDirect(f, simplecpp::simplifyPath(includePath + "/" + header));
         if (!path.empty())
             return path;
     }
     return "";
 }
 
-static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader)
+std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::tryload(FileDataCache::name_map_type::iterator &name_it, const simplecpp::DUI &dui, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
 {
-    if (isAbsolutePath(header))
-        return openHeader(f, header);
+    const std::string &path = name_it->first;
+    FileID fileId;
 
-    // prefer first to search the header relatively to source file if found, when not a system header
-    if (!systemheader) {
-        std::string relativeHeader = openHeaderRelative(f, sourcefile, header);
-        if (!relativeHeader.empty()) {
-            return relativeHeader;
-        }
+    if (!getFileId(path, fileId))
+        return {nullptr, false};
+
+    const auto id_it = mIdMap.find(fileId);
+    if (id_it != mIdMap.end()) {
+        name_it->second = id_it->second;
+        return {id_it->second, false};
     }
 
-    // search the header on the include paths (provided by the flags "-I...")
-    return openHeaderIncludePath(f, dui, header);
-}
+    std::ifstream f(path);
+    FileData *const data = new FileData {path, TokenList(f, filenames, path, outputList)};
 
-static std::string findPathInMapBothRelativeAndAbsolute(const std::map<std::string, simplecpp::TokenList *> &filedata, const std::string& path) {
-    // here there are two possibilities - either we match this from absolute path or from a relative one
-    if (filedata.find(path) != filedata.end()) {// try first to respect the exact match
-        return path;
-    }
+    if (dui.removeComments)
+        data->tokens.removeComments();
 
-    // otherwise - try to use the normalize to the correct representation
-    std::string alternativePath;
-    if (isAbsolutePath(path)) {
-        alternativePath = extractRelativePathFromAbsolute(simplecpp::simplifyPath(path));
-    } else {
-        alternativePath = toAbsolutePath(path);
-    }
+    name_it->second = data;
+    mIdMap.emplace(fileId, data);
+    mData.emplace_back(data);
 
-    if (filedata.find(alternativePath) != filedata.end()) {
-        return alternativePath;
-    }
-    return "";
+    return {data, true};
 }
 
-static std::string getFileIdPath(const std::map<std::string, simplecpp::TokenList *> &filedata, const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader)
+std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get(const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
 {
-    if (filedata.empty()) {
-        return "";
-    }
     if (isAbsolutePath(header)) {
-        const std::string simplifiedHeaderPath = simplecpp::simplifyPath(header);
-        const std::string match = findPathInMapBothRelativeAndAbsolute(filedata, simplifiedHeaderPath);
-        if (!match.empty()) {
-            return match;
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(header), nullptr);
+
+        if (ins.second) {
+            const auto ret = tryload(ins.first, dui, filenames, outputList);
+            if (ret.first != nullptr) {
+                return ret;
+            }
+        } else {
+            return {ins.first->second, false};
         }
+
+        return {nullptr, false};
     }
 
     if (!systemheader) {
-        const std::string relativeFilename = getRelativeFileName(sourcefile, header, true);
-        const std::string match = findPathInMapBothRelativeAndAbsolute(filedata, relativeFilename);
-        if (!match.empty()) {
-            return match;
-        }
-        // if the file exists but hasn't been loaded yet then we need to stop searching here or we could get a false match
-        std::ifstream f;
-        openHeader(f, relativeFilename);
-        if (f.is_open()) {
-            f.close();
-            return "";
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(dirPath(sourcefile) + header), nullptr);
+
+        if (ins.second) {
+            const auto ret = tryload(ins.first, dui, filenames, outputList);
+            if (ret.first != nullptr) {
+                return ret;
+            }
+        } else if (ins.first->second != nullptr) {
+            return {ins.first->second, false};
         }
-    } else if (filedata.find(header) != filedata.end()) {
-        return header;// system header that its file is already in the filedata - return that as is
     }
 
-    for (std::list<std::string>::const_iterator it = dui.includePaths.begin(); it != dui.includePaths.end(); ++it) {
-        const std::string match = findPathInMapBothRelativeAndAbsolute(filedata, getIncludePathFileName(*it, header));
-        if (!match.empty()) {
-            return match;
+    for (const auto &includePath : dui.includePaths) {
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(includePath + "/" + header), nullptr);
+
+        if (ins.second) {
+            const auto ret = tryload(ins.first, dui, filenames, outputList);
+            if (ret.first != nullptr) {
+                return ret;
+            }
+        } else if (ins.first->second != nullptr) {
+            return {ins.first->second, false};
         }
     }
 
-    return "";
+    return {nullptr, false};
 }
 
-static bool hasFile(const std::map<std::string, simplecpp::TokenList *> &filedata, const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader)
+bool simplecpp::FileDataCache::getFileId(const std::string &path, FileID &id)
 {
-    return !getFileIdPath(filedata, sourcefile, header, dui, systemheader).empty();
-}
+#ifdef SIMPLECPP_WINDOWS
+    HANDLE hFile = CreateFileA(path.c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
-static void safeInsertTokenListToMap(std::map<std::string, simplecpp::TokenList *> &filedata, const std::string &header2, simplecpp::TokenList *tokens, const std::string &header, const std::string &sourcefile, bool systemheader, const char* contextDesc)
-{
-    const bool inserted = filedata.insert(std::make_pair(header2, tokens)).second;
-    if (!inserted) {
-        std::cerr << "error in " << contextDesc << " - attempt to add a tokenized file to the file map, but this file is already in the map! Details:" <<
-            "header: " << header << " header2: " << header2 << " source: " << sourcefile << " systemheader: " << systemheader << std::endl;
-        std::abort();
-    }
+    if (hFile == INVALID_HANDLE_VALUE)
+        return false;
+
+    const BOOL ret = GetFileInformationByHandleEx(hFile, FileIdInfo, &id.fileIdInfo, sizeof(id.fileIdInfo));
+
+    CloseHandle(hFile);
+
+    return ret == TRUE;
+#else
+    struct stat statbuf;
+
+    if (stat(path.c_str(), &statbuf) != 0)
+        return false;
+
+    id.dev = statbuf.st_dev;
+    id.ino = statbuf.st_ino;
+
+    return true;
+#endif
 }
 
-std::map<std::string, simplecpp::TokenList*> simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList *outputList)
+simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList *outputList)
 {
 #ifdef SIMPLECPP_WINDOWS
     if (dui.clearIncludeCache)
         nonExistingFilesCache.clear();
 #endif
 
-    std::map<std::string, simplecpp::TokenList*> ret;
+    FileDataCache cache;
 
     std::list<const Token *> filelist;
 
     // -include files
     for (std::list<std::string>::const_iterator it = dui.includes.begin(); it != dui.includes.end(); ++it) {
-        const std::string &filename = realFilename(*it);
+        const std::string &filename = *it;
 
-        if (ret.find(filename) != ret.end())
-            continue;
+        const auto loadResult = cache.get("", filename, dui, false, filenames, outputList);
+        const bool loaded = loadResult.second;
+        FileData *const filedata = loadResult.first;
 
-        std::ifstream fin(filename.c_str());
-        if (!fin.is_open()) {
+        if (filedata == nullptr) {
             if (outputList) {
                 simplecpp::Output err(filenames);
                 err.type = simplecpp::Output::EXPLICIT_INCLUDE_NOT_FOUND;
@@ -3335,18 +3115,17 @@ std::map<std::string, simplecpp::TokenList*> simplecpp::load(const simplecpp::To
             }
             continue;
         }
-        fin.close();
 
-        TokenList *tokenlist = new TokenList(filename, filenames, outputList);
-        if (!tokenlist->front()) {
-            delete tokenlist;
+        if (!loaded)
+            continue;
+
+        if (!filedata->tokens.front())
             continue;
-        }
 
         if (dui.removeComments)
-            tokenlist->removeComments();
-        ret[filename] = tokenlist;
-        filelist.push_back(tokenlist->front());
+            filedata->tokens.removeComments();
+
+        filelist.push_back(filedata->tokens.front());
     }
 
     for (const Token *rawtok = rawtokens.cfront(); rawtok || !filelist.empty(); rawtok = rawtok ? rawtok->next : nullptr) {
@@ -3369,25 +3148,20 @@ std::map<std::string, simplecpp::TokenList*> simplecpp::load(const simplecpp::To
             continue;
 
         const bool systemheader = (htok->str()[0] == '<');
-        const std::string header(realFilename(htok->str().substr(1U, htok->str().size() - 2U)));
-        if (hasFile(ret, sourcefile, header, dui, systemheader))
-            continue;
+        const std::string header(htok->str().substr(1U, htok->str().size() - 2U));
 
-        std::ifstream f;
-        const std::string header2 = openHeader(f,dui,sourcefile,header,systemheader);
-        if (!f.is_open())
+        FileData *const filedata = cache.get(sourcefile, header, dui, systemheader, filenames, outputList).first;
+        if (!filedata)
             continue;
-        f.close();
 
-        TokenList *tokens = new TokenList(header2, filenames, outputList);
         if (dui.removeComments)
-            tokens->removeComments();
-        safeInsertTokenListToMap(ret, header2, tokens, header, rawtok->location.file(), systemheader, "simplecpp::load");
-        if (tokens->front())
-            filelist.push_back(tokens->front());
+            filedata->tokens.removeComments();
+
+        if (filedata->tokens.front())
+            filelist.push_back(filedata->tokens.front());
     }
 
-    return ret;
+    return cache;
 }
 
 static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token **tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList *outputList)
@@ -3443,7 +3217,7 @@ static std::string getTimeDefine(const struct tm *timep)
     return std::string("\"").append(buf).append("\"");
 }
 
-void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, std::map<std::string, simplecpp::TokenList *> &filedata, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage, std::list<simplecpp::IfCond> *ifCond)
+void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, simplecpp::FileDataCache &cache, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage, std::list<simplecpp::IfCond> *ifCond)
 {
 #ifdef SIMPLECPP_WINDOWS
     if (dui.clearIncludeCache)
@@ -3535,9 +3309,9 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
 
     includetokenstack.push(rawtokens.cfront());
     for (std::list<std::string>::const_iterator it = dui.includes.begin(); it != dui.includes.end(); ++it) {
-        const std::map<std::string, TokenList*>::const_iterator f = filedata.find(*it);
-        if (f != filedata.end())
-            includetokenstack.push(f->second->cfront());
+        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;
@@ -3668,21 +3442,9 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                 const Token * const inctok = inc2.cfront();
 
                 const bool systemheader = (inctok->str()[0] == '<');
-                const std::string header(realFilename(inctok->str().substr(1U, inctok->str().size() - 2U)));
-                std::string header2 = getFileIdPath(filedata, rawtok->location.file(), header, dui, systemheader);
-                if (header2.empty()) {
-                    // try to load file..
-                    std::ifstream f;
-                    header2 = openHeader(f, dui, rawtok->location.file(), header, systemheader);
-                    if (f.is_open()) {
-                        f.close();
-                        TokenList * const tokens = new TokenList(header2, files, outputList);
-                        if (dui.removeComments)
-                            tokens->removeComments();
-                        safeInsertTokenListToMap(filedata, header2, tokens, header, rawtok->location.file(), systemheader, "simplecpp::preprocess");
-                    }
-                }
-                if (header2.empty()) {
+                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;
+                if (filedata == nullptr) {
                     if (outputList) {
                         simplecpp::Output out(files);
                         out.type = Output::MISSING_HEADER;
@@ -3698,10 +3460,9 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                         out.msg = "#include nested too deeply";
                         outputList->push_back(out);
                     }
-                } else if (pragmaOnce.find(header2) == pragmaOnce.end()) {
+                } else if (pragmaOnce.find(filedata->filename) == pragmaOnce.end()) {
                     includetokenstack.push(gotoNextLine(rawtok));
-                    const TokenList * const includetokens = filedata.find(header2)->second;
-                    rawtok = includetokens ? includetokens->cfront() : nullptr;
+                    rawtok = filedata->tokens.cfront();
                     continue;
                 }
             } else if (rawtok->str() == IF || rawtok->str() == IFDEF || rawtok->str() == IFNDEF || rawtok->str() == ELIF) {
@@ -3778,12 +3539,10 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                                 if (systemheader) {
                                     while ((tok = tok->next) && tok->op != '>')
                                         header += tok->str();
-                                    // cppcheck-suppress selfAssignment - platform-dependent implementation
-                                    header = realFilename(header);
                                     if (tok && tok->op == '>')
                                         closingAngularBracket = true;
                                 } else {
-                                    header = realFilename(tok->str().substr(1U, tok->str().size() - 2U));
+                                    header = tok->str().substr(1U, tok->str().size() - 2U);
                                     closingAngularBracket = true;
                                 }
                                 std::ifstream f;
@@ -3931,11 +3690,9 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     }
 }
 
-void simplecpp::cleanup(std::map<std::string, TokenList*> &filedata)
+void simplecpp::cleanup(FileDataCache &cache)
 {
-    for (std::map<std::string, TokenList*>::iterator it = filedata.begin(); it != filedata.end(); ++it)
-        delete it->second;
-    filedata.clear();
+    cache.clear();
 }
 
 simplecpp::cstd_t simplecpp::getCStd(const std::string &std)
diff --git a/simplecpp.h b/simplecpp.h
index 9fd95808..b69bfee4 100755
--- a/simplecpp.h
+++ b/simplecpp.h
@@ -6,13 +6,19 @@
 #ifndef simplecppH
 #define simplecppH
 
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
+#  define SIMPLECPP_WINDOWS
+#endif
+
 #include <cctype>
 #include <cstring>
 #include <iosfwd>
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #ifdef _WIN32
@@ -27,6 +33,12 @@
 #  define SIMPLECPP_LIB
 #endif
 
+#ifdef SIMPLECPP_WINDOWS
+#  include <cstdint>
+#else
+#  include <sys/stat.h>
+#endif
+
 #if defined(_MSC_VER)
 #  pragma warning(push)
 // suppress warnings about "conversion from 'type1' to 'type2', possible loss of data"
@@ -43,6 +55,7 @@ namespace simplecpp {
 
     typedef std::string TokenString;
     class Macro;
+    class FileDataCache;
 
     /**
      * Location in source code
@@ -341,7 +354,7 @@ namespace simplecpp {
 
     SIMPLECPP_LIB long long characterLiteralToLL(const std::string& str);
 
-    SIMPLECPP_LIB std::map<std::string, TokenList*> load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = nullptr);
+    SIMPLECPP_LIB FileDataCache load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = nullptr);
 
     /**
      * Preprocess
@@ -349,18 +362,18 @@ namespace simplecpp {
      * @param output TokenList that receives the preprocessing output
      * @param rawtokens Raw tokenlist for top sourcefile
      * @param files internal data of simplecpp
-     * @param filedata output from simplecpp::load()
+     * @param cache output from simplecpp::load()
      * @param dui defines, undefs, and include paths
      * @param outputList output: list that will receive output messages
      * @param macroUsage output: macro usage
      * @param ifCond output: #if/#elif expressions
      */
-    SIMPLECPP_LIB void preprocess(TokenList &output, const TokenList &rawtokens, std::vector<std::string> &files, std::map<std::string, TokenList*> &filedata, const DUI &dui, OutputList *outputList = nullptr, std::list<MacroUsage> *macroUsage = nullptr, std::list<IfCond> *ifCond = nullptr);
+    SIMPLECPP_LIB void preprocess(TokenList &output, const TokenList &rawtokens, std::vector<std::string> &files, FileDataCache &cache, const DUI &dui, OutputList *outputList = nullptr, std::list<MacroUsage> *macroUsage = nullptr, std::list<IfCond> *ifCond = nullptr);
 
     /**
      * Deallocate data
      */
-    SIMPLECPP_LIB void cleanup(std::map<std::string, TokenList*> &filedata);
+    SIMPLECPP_LIB void cleanup(FileDataCache &cache);
 
     /** Simplify path */
     SIMPLECPP_LIB std::string simplifyPath(std::string path);
@@ -381,6 +394,116 @@ 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);
+
+    struct SIMPLECPP_LIB FileData {
+        /** The canonical filename associated with this data */
+        std::string filename;
+        /** The tokens associated with this file */
+        TokenList tokens;
+    };
+
+    class SIMPLECPP_LIB FileDataCache {
+    public:
+        FileDataCache() = default;
+
+        FileDataCache(const FileDataCache &) = delete;
+        FileDataCache(FileDataCache &&) = default;
+
+        FileDataCache &operator=(const FileDataCache &) = delete;
+        FileDataCache &operator=(FileDataCache &&) = default;
+
+        /** Get the cached data for a file, or load and then return it if it isn't cached.
+         *  returns the file data and true if the file was loaded, false if it was cached. */
+        std::pair<FileData *, bool> get(const std::string &sourcefile, const std::string &header, const DUI &dui, bool systemheader, std::vector<std::string> &filenames, OutputList *outputList);
+
+        void insert(FileData data) {
+            FileData *const newdata = new FileData(std::move(data));
+
+            mData.emplace_back(newdata);
+            mNameMap.emplace(newdata->filename, newdata);
+        }
+
+        void clear() {
+            mNameMap.clear();
+            mIdMap.clear();
+            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;
+
+        size_type size() const {
+            return mData.size();
+        }
+        iterator begin() {
+            return mData.begin();
+        }
+        iterator end() {
+            return mData.end();
+        }
+        const_iterator begin() const {
+            return mData.begin();
+        }
+        const_iterator end() const {
+            return mData.end();
+        }
+        const_iterator cbegin() const {
+            return mData.cbegin();
+        }
+        const_iterator cend() const {
+            return mData.cend();
+        }
+
+    private:
+        struct FileID {
+#ifdef SIMPLECPP_WINDOWS
+            struct {
+                std::uint64_t VolumeSerialNumber;
+                struct {
+                    std::uint64_t IdentifierHi;
+                    std::uint64_t IdentifierLo;
+                } FileId;
+            } fileIdInfo;
+
+            bool operator==(const FileID &that) const noexcept {
+                return fileIdInfo.VolumeSerialNumber == that.fileIdInfo.VolumeSerialNumber &&
+                       fileIdInfo.FileId.IdentifierHi == that.fileIdInfo.FileId.IdentifierHi &&
+                       fileIdInfo.FileId.IdentifierLo == that.fileIdInfo.FileId.IdentifierLo;
+            }
+#else
+            dev_t dev;
+            ino_t ino;
+
+            bool operator==(const FileID& that) const noexcept {
+                return dev == that.dev && ino == that.ino;
+            }
+#endif
+            struct Hasher {
+                std::size_t operator()(const FileID &id) const {
+#ifdef SIMPLECPP_WINDOWS
+                    return static_cast<std::size_t>(id.fileIdInfo.FileId.IdentifierHi ^ id.fileIdInfo.FileId.IdentifierLo ^
+                                                    id.fileIdInfo.VolumeSerialNumber);
+#else
+                    return static_cast<std::size_t>(id.dev) ^ static_cast<std::size_t>(id.ino);
+#endif
+                }
+            };
+        };
+
+        using name_map_type = std::unordered_map<std::string, FileData *>;
+        using id_map_type = std::unordered_map<FileID, FileData *, FileID::Hasher>;
+
+        static bool getFileId(const std::string &path, FileID &id);
+
+        std::pair<FileData *, bool> tryload(name_map_type::iterator &name_it, const DUI &dui, std::vector<std::string> &filenames, OutputList *outputList);
+
+        container_type mData;
+        name_map_type mNameMap;
+        id_map_type mIdMap;
+
+    };
 }
 
 #if defined(_MSC_VER)
diff --git a/test.cpp b/test.cpp
index caa6137e..d1eeeae6 100644
--- a/test.cpp
+++ b/test.cpp
@@ -10,7 +10,6 @@
 #include <cstring>
 #include <exception>
 #include <iostream>
-#include <map>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -100,13 +99,12 @@ static std::string readfile(const char code[], std::size_t size, simplecpp::Outp
 static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList)
 {
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens = makeTokenList(code,files);
     tokens.removeComments();
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, tokens, files, filedata, dui, outputList);
-    for (auto &i : filedata)
-        delete i.second;
+    simplecpp::preprocess(tokens2, tokens, files, cache, dui, outputList);
+    simplecpp::cleanup(cache);
     return tokens2.stringify();
 }
 
@@ -1077,11 +1075,11 @@ static void error4()
     // "#error x\n1"
     const char code[] = "\xFE\xFF\x00\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x31";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     const simplecpp::TokenList rawtoken = makeTokenList(code, sizeof(code),files,"test.c");
-    simplecpp::preprocess(tokens2, rawtoken, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::preprocess(tokens2, rawtoken, files, cache, simplecpp::DUI(), &outputList);
     ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));
 }
 
@@ -1090,11 +1088,11 @@ static void error5()
     // "#error x\n1"
     const char code[] = "\xFF\xFE\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x78\x00\x31\x00";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code, sizeof(code),files,"test.c");
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI(), &outputList);
     ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));
 }
 
@@ -1935,12 +1933,14 @@ static void missingHeader2()
 {
     const char code[] = "#include \"foo.h\"\n"; // this file exists
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
-    filedata["foo.h"] = nullptr;
+    simplecpp::FileDataCache cache;
+    cache.insert({"foo.h", simplecpp::TokenList(files)});
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::DUI dui;
+    dui.includePaths.push_back(".");
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
     ASSERT_EQUALS("", toString(outputList));
 }
 
@@ -1964,13 +1964,15 @@ static void nestedInclude()
 {
     const char code[] = "#include \"test.h\"\n";
     std::vector<std::string> files;
-    simplecpp::TokenList rawtokens = makeTokenList(code,files,"test.h");
-    std::map<std::string, simplecpp::TokenList*> filedata;
-    filedata["test.h"] = &rawtokens;
+    const simplecpp::TokenList rawtokens = makeTokenList(code,files,"test.h");
+    simplecpp::FileDataCache cache;
+    cache.insert({"test.h", rawtokens});
 
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::DUI dui;
+    dui.includePaths.push_back(".");
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
 
     ASSERT_EQUALS("file0,1,include_nested_too_deeply,#include nested too deeply\n", toString(outputList));
 }
@@ -1979,14 +1981,16 @@ static void systemInclude()
 {
     const char code[] = "#include <limits.h>\n";
     std::vector<std::string> files;
-    simplecpp::TokenList rawtokens = makeTokenList(code,files,"local/limits.h");
-    std::map<std::string, simplecpp::TokenList*> filedata;
-    filedata["limits.h"] = nullptr;
-    filedata["local/limits.h"] = &rawtokens;
+    const simplecpp::TokenList rawtokens = makeTokenList(code,files,"local/limits.h");
+    simplecpp::FileDataCache cache;
+    cache.insert({"include/limits.h", simplecpp::TokenList(files)});
+    cache.insert({"local/limits.h", rawtokens});
 
     simplecpp::OutputList outputList;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI(), &outputList);
+    simplecpp::DUI dui;
+    dui.includePaths.push_back("include");
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, dui, &outputList);
 
     ASSERT_EQUALS("", toString(outputList));
 }
@@ -2008,9 +2012,9 @@ static void multiline2()
     simplecpp::TokenList rawtokens = makeTokenList(code,files);
     ASSERT_EQUALS("# define A /**/ 1\n\nA", rawtokens.stringify());
     rawtokens.removeComments();
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("\n\n1", tokens2.stringify());
 }
 
@@ -2023,9 +2027,9 @@ static void multiline3()   // #28 - macro with multiline comment
     simplecpp::TokenList rawtokens = makeTokenList(code,files);
     ASSERT_EQUALS("# define A /*           */ 1\n\nA", rawtokens.stringify());
     rawtokens.removeComments();
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("\n\n1", tokens2.stringify());
 }
 
@@ -2039,9 +2043,9 @@ static void multiline4()   // #28 - macro with multiline comment
     simplecpp::TokenList rawtokens = makeTokenList(code,files);
     ASSERT_EQUALS("# define A /*           */ 1\n\n\nA", rawtokens.stringify());
     rawtokens.removeComments();
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokens2, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("\n\n\n1", tokens2.stringify());
 }
 
@@ -2155,19 +2159,21 @@ static void include3()   // #16 - crash when expanding macro from header
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("A.c", files[0]);
     ASSERT_EQUALS("A.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["A.c"] = &rawtokens_c;
-    filedata["A.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"A.c", rawtokens_c});
+    cache.insert({"A.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, simplecpp::DUI());
+    simplecpp::DUI dui;
+    dui.includePaths.push_back(".");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n1234", out.stringify());
 }
@@ -2180,21 +2186,22 @@ static void include4()   // #27 - -include
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "27.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "27.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "27.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "27.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("27.c", files[0]);
     ASSERT_EQUALS("27.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["27.c"] = &rawtokens_c;
-    filedata["27.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"27.c", rawtokens_c});
+    cache.insert({"27.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
+    dui.includePaths.push_back(".");
     dui.includes.push_back("27.h");
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, dui);
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("123", out.stringify());
 }
@@ -2206,19 +2213,21 @@ static void include5()    // #3 - handle #include MACRO
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("3.c", files[0]);
     ASSERT_EQUALS("3.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["3.c"] = &rawtokens_c;
-    filedata["3.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"3.c", rawtokens_c});
+    cache.insert({"3.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, simplecpp::DUI());
+    simplecpp::DUI dui;
+    dui.includePaths.push_back(".");
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 1 \"3.h\"\n123", out.stringify());
 }
@@ -2229,16 +2238,16 @@ static void include6()   // #57 - incomplete macro  #include MACRO(,)
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens = makeTokenList(code, files, "57.c");
+    const simplecpp::TokenList rawtokens = makeTokenList(code, files, "57.c");
 
     ASSERT_EQUALS(1U, files.size());
     ASSERT_EQUALS("57.c", files[0]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["57.c"] = &rawtokens;
+    simplecpp::FileDataCache cache;
+    cache.insert({"57.c", rawtokens});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(out, rawtokens, files, cache, simplecpp::DUI());
 }
 
 
@@ -2250,21 +2259,21 @@ static void include7()    // #include MACRO
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "3.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "3.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("3.c", files[0]);
     ASSERT_EQUALS("3.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["3.c"] = &rawtokens_c;
-    filedata["3.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"3.c", rawtokens_c});
+    cache.insert({"3.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
     dui.includePaths.push_back(".");
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, dui);
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 1 \"3.h\"\n123", out.stringify());
 }
@@ -2288,21 +2297,21 @@ static void include9()
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "1.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "1.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "1.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "1.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("1.c", files[0]);
     ASSERT_EQUALS("1.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["1.c"] = &rawtokens_c;
-    filedata["1.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"1.c", rawtokens_c});
+    cache.insert({"1.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
     simplecpp::DUI dui;
     dui.includePaths.push_back(".");
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, dui);
+    simplecpp::preprocess(out, rawtokens_c, files, cache, dui);
 
     ASSERT_EQUALS("\n#line 2 \"1.h\"\nx = 1 ;", out.stringify());
 }
@@ -2470,19 +2479,21 @@ static void stringify1()
 
     std::vector<std::string> files;
 
-    simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
-    simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
+    const simplecpp::TokenList rawtokens_c = makeTokenList(code_c, files, "A.c");
+    const simplecpp::TokenList rawtokens_h = makeTokenList(code_h, files, "A.h");
 
     ASSERT_EQUALS(2U, files.size());
     ASSERT_EQUALS("A.c", files[0]);
     ASSERT_EQUALS("A.h", files[1]);
 
-    std::map<std::string, simplecpp::TokenList *> filedata;
-    filedata["A.c"] = &rawtokens_c;
-    filedata["A.h"] = &rawtokens_h;
+    simplecpp::FileDataCache cache;
+    cache.insert({"A.c", rawtokens_c});
+    cache.insert({"A.h", rawtokens_h});
 
     simplecpp::TokenList out(files);
-    simplecpp::preprocess(out, rawtokens_c, files, filedata, simplecpp::DUI());
+    simplecpp::DUI dui;
+    dui.includePaths.push_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());
 }
@@ -2492,10 +2503,10 @@ static void tokenMacro1()
     const char code[] = "#define A 123\n"
                         "A";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     ASSERT_EQUALS("A", tokenList.cback()->macro);
 }
 
@@ -2504,10 +2515,10 @@ static void tokenMacro2()
     const char code[] = "#define ADD(X,Y) X+Y\n"
                         "ADD(1,2)";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token *tok = tokenList.cfront();
     ASSERT_EQUALS("1", tok->str());
     ASSERT_EQUALS("", tok->macro);
@@ -2525,10 +2536,10 @@ static void tokenMacro3()
                         "#define FRED  1\n"
                         "ADD(FRED,2)";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token *tok = tokenList.cfront();
     ASSERT_EQUALS("1", tok->str());
     ASSERT_EQUALS("FRED", tok->macro);
@@ -2546,10 +2557,10 @@ static void tokenMacro4()
                         "#define B 1\n"
                         "A";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token * const tok = tokenList.cfront();
     ASSERT_EQUALS("1", tok->str());
     ASSERT_EQUALS("A", tok->macro);
@@ -2561,10 +2572,10 @@ static void tokenMacro5()
                         "#define SET_BPF_JUMP(code) SET_BPF(D | code)\n"
                         "SET_BPF_JUMP(A | B | C);";
     std::vector<std::string> files;
-    std::map<std::string, simplecpp::TokenList*> filedata;
+    simplecpp::FileDataCache cache;
     simplecpp::TokenList tokenList(files);
     const simplecpp::TokenList rawtokens = makeTokenList(code,files);
-    simplecpp::preprocess(tokenList, rawtokens, files, filedata, simplecpp::DUI());
+    simplecpp::preprocess(tokenList, rawtokens, files, cache, simplecpp::DUI());
     const simplecpp::Token * const tok = tokenList.cfront()->next;
     ASSERT_EQUALS("D", tok->str());
     ASSERT_EQUALS("SET_BPF_JUMP", tok->macro);
@@ -2998,8 +3009,8 @@ static void preprocess_files()
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("", *files.cbegin());
 
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens, files, filedata, simplecpp::DUI(), nullptr);
+        simplecpp::FileDataCache cache;
+        simplecpp::preprocess(tokens2, tokens, files, cache, simplecpp::DUI(), nullptr);
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("", *files.cbegin());
     }
@@ -3015,8 +3026,8 @@ static void preprocess_files()
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("test.cpp", *files.cbegin());
 
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens, files, filedata, simplecpp::DUI(), nullptr);
+        simplecpp::FileDataCache cache;
+        simplecpp::preprocess(tokens2, tokens, files, cache, simplecpp::DUI(), nullptr);
         ASSERT_EQUALS(1, files.size());
         ASSERT_EQUALS("test.cpp", *files.cbegin());
     }