René's URL Explorer Experiment

Title: Include and path handling optimization by glankk · Pull Request #447 · cppcheck-opensource/simplecpp · GitHub

Open Graph Title: Include and path handling optimization by glankk · Pull Request #447 · cppcheck-opensource/simplecpp

X Title: Include and path handling optimization by glankk · Pull Request #447 · cppcheck-opensource/simplecpp

Description: This is a draft with some suggested changes to how includes are handled. There are several style issues at the moment, but I would like to discuss the overall approach before addressing those. The changes to the include lookup procedure are based on the observation that files are very often included multiple times, but very rarely included with a different name. To take advantage of this, the lookup procedure first tries to do an optimistic match using the quick and simple path canonicalization provided by simplifyPath. In the rare case that a file is included with a name that hasn't been seen before (due to absoluteness change, capitalization, or link), then and only then is that file compared against the cached files using a more accurate but expensive procedure. For the case where the file identity cannot be determined with simplifyPath, the file id is used (FILE_ID_INFO on windows, st_dev & st_ino on linux). This combined with the fact that file identity checking is delayed until absolutely necessary means that all calls to realFilename have been removed. This is where most of the timesave comes from. Using file id means that the lookup procedure has less platform-specific code (only for getting and comparing the file id), and the behavior for case-sensitivty and links is uniform across platforms. The behavior for symlinks matches that of gcc and clang, which is to allows pragma once to work when a file is included with a different name. There's no standard definition for what pragma once should do, but personally I think this is the desired behavior. Intuitively, there are no situations where it is desirable for #pragma once to produce redefinition errors if a file is included multiple times using different names. The code runs about 2 minutes faster for a large test case on windows with many nested includes (12m40s down from 14m40s), though it's a contrived test case so I'm not sure how representative that is of a real use case. Some other things; The new procedure requires some additional metadata. Instead of adding more static data in simplecpp, I've opted to place both the token lists and metadata in a new class for the sake of better structure. Other file-specific optimizations could also be facilitated by this such as the multiple-include optimization used by gcc, though using a class is not strictly necessary and does incur a change to the simplecpp interface. Some c++11 features are used, but these could be removed or placed in ifdefs. The rules for how simplecpp should search for headers are not always clear, ideally this would be stated precisely somewhere to make sure that the implementation is correct. Specifically, gcc and clang does not look in the current working directory unless -I. is explicitly passed, but simplecpp does. I would like to clarify whether or not this is intentional or if the behavior should match other compilers.

Open Graph Description: This is a draft with some suggested changes to how includes are handled. There are several style issues at the moment, but I would like to discuss the overall approach before addressing those. The ...

X Description: This is a draft with some suggested changes to how includes are handled. There are several style issues at the moment, but I would like to discuss the overall approach before addressing those. The ...

Opengraph URL: https://github.com/cppcheck-opensource/simplecpp/pull/447

X: @github

direct link

Domain: github.com

Links:

Viewport: width=device-width