Is include path lookup somehow supported in the standard library? - c++

Question

I know the C++ standard library caters to C++ programs, not C++ compilers. But - is there some facility in the standard library for looking up include files - on the filesystem or wherever they would get looked up in on the target system - given the kind of string you would use in an include directive (i.e. <foo/bar.h> or "foo/bar.h")?

Answer 1

I don't think there is a built-in tool which implements that and the main problem with that is that the standard doesn't seem to have this logic standardised. [cpp.include] part describes it as follows (emphasis mine):
A preprocessing directive of the form
# include < h-char-sequence > new-line
searches a sequence of implementation-defined places for a header identified uniquely by the specified sequence between the < and > delimiters, and causes the replacement of that directive by the entire contents of the header. How the places are specified or the header identified is implementation-defined.
A preprocessing directive of the form
# include " q-char-sequence " new-line
causes the replacement of that directive by the entire contents of the source file identified by the specified sequence between the " delimiters. The named source file is searched for in an implementation-defined manner. If this search is not supported, or if the search fails, the directive is reprocessed as if it read
# include < h-char-sequence > new-line
with the identical contained sequence (including > characters, if any) from the original directive.
Thus, the only thing we reliably know from the standard is that there is a fallback rule from an implementation-defined lookup of "q-char-sequence" to another implementation-defined lookup of <h-char-sequence> (while filesystem is compiler-agnostic and rather platform-dependent, this lookup rule is the other way around - compiler-dependent but almost-platform-agnostic)
I was, however, once assigned an entry-test task to implement a tool which finds the missing and cyclic includes. For that task I took the conventional rules where ".." tokens are searched for in the current directory and <..> are searched for in the "system-folders". In this scenario, the logic of such a function looks quite straightforward:
tdw::Analyser::path_type tdw::Analyser::findIncludeParentPath(const Include& _sourceFile, const path_type _currentPath, const std::vector<path_type>& _includePaths) {
using namespace std::filesystem;
// Follows C standard "6.10.2 Source file inclusion" - http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf#page=182
if(_sourceFile.type == Include::Type::q_char) {
const auto searchPath = _currentPath / _sourceFile.path;
if(is_regular_file(searchPath)) {
return _currentPath;
}
}
for(const auto& includePath : _includePaths) {
const auto searchPath = includePath / _sourceFile.path;
if(is_regular_file(searchPath)) {
return includePath;
}
}
return path_type();
}
The parameters and types have the following meaning:
tdw::Analyser::path_type is just an alias of form using path_type = typename std::filesystem::path;
Include describes a separate include entry as follows:
struct Include {
enum class Type {
q_char, h_char, pp_tokens
};
const path_type path;
const Type type;
};
Here path doesn't refer to absolute path, but rather h-char-sequence or q-char-sequence parsed from corresponding directives.
_sourceFile - a file where include directive is found in
_currentPath - the (absolute) path, _sourceFile is located in
_includePaths - the paths where h-char-sequence tokens are supposed to be looked for in
P.S. You can find complete project here.