This is an archive of the discontinued LLVM Phabricator instance.

Differential D21787

[include-fixer] make HeaderMapCollector maps from regex instead of postfix.
ClosedPublic

Authored by ioeric on Jun 28 2016, 1:45 AM.

Details

Reviewers
bkramer
Commits
rGf33bc95f8f6a: [include-fixer] make HeaderMapCollector maps from regex instead of postfix.
rCTE274494: [include-fixer] make HeaderMapCollector maps from regex instead of postfix.
rL274494: [include-fixer] make HeaderMapCollector maps from regex instead of postfix.
Summary

this enables us to map a group of headers to one header name,
e.g. headers from one directory can be mapped to the same header.

Diff Detail

Event Timeline

ioeric updated this revision to Diff 62071.Jun 28 2016, 1:45 AM
ioeric retitled this revision from to [include-fixer] make HeaderMapCollector maps from regex instead of postfix..
ioeric updated this object.
ioeric added a reviewer: bkramer.
ioeric added subscribers: hokein, cfe-commits.
ioeric added a comment.Jul 4 2016, 1:34 AM

Ping

bkramer added inline comments.Jul 4 2016, 1:42 AM
include-fixer/find-all-symbols/STLPostfixHeaderMap.cpp
14–15

Can we make this a std::vector<std::pair<llvm::Regex, const char *>>? Creating llvm::Regex is somewhat expensive so we only want to do it once. We also never lookup into the postfix header map and only iterate over it so using a StringMap for it is wasteful.

ioeric updated this revision to Diff 62656.Jul 4 2016, 3:05 AM
ioeric marked an inline comment as done.
  • Change RegexHeaderMap from StringMap to std::vector<std::pair<StringRef, StringRef>>.
include-fixer/find-all-symbols/STLPostfixHeaderMap.cpp
14–15

As per our offline discussion, copy constructor of llvm::Regex is deleted and the non-const match function prevents us from making the header map const. So we use std::vector<std::pair<StringRef, StringRef>> instead.

bkramer accepted this revision.Jul 4 2016, 3:31 AM
bkramer edited edge metadata.

If the regex construction turns out to be too slow we can fix it later. LGTM for now.

This revision is now accepted and ready to land.Jul 4 2016, 3:31 AM
Closed by commit rL274494: [include-fixer] make HeaderMapCollector maps from regex instead of postfix. (authored by ioeric). · Explain WhyJul 4 2016, 4:30 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
include-fixer/
find-all-symbols/
10 lines
5 lines
19 lines
11 lines
2 lines
1258 lines
unittests/
include-fixer/
find-all-symbols/
11 lines

Diff 62656

include-fixer/find-all-symbols/FindAllSymbolsAction.h

Show All 19 Lines
namespace clang { namespace clang {
namespace find_all_symbols { namespace find_all_symbols {
class FindAllSymbolsAction : public clang::ASTFrontendAction { class FindAllSymbolsAction : public clang::ASTFrontendAction {
public: public:
explicit FindAllSymbolsAction( explicit FindAllSymbolsAction(
SymbolReporter *Reporter, SymbolReporter *Reporter,
const HeaderMapCollector::HeaderMap *PostfixMap = nullptr); const HeaderMapCollector::RegexHeaderMap *RegexHeaderMap = nullptr);
std::unique_ptr<clang::ASTConsumer> std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &Compiler, CreateASTConsumer(clang::CompilerInstance &Compiler,
StringRef InFile) override; StringRef InFile) override;
private: private:
SymbolReporter *const Reporter; SymbolReporter *const Reporter;
clang::ast_matchers::MatchFinder MatchFinder; clang::ast_matchers::MatchFinder MatchFinder;
HeaderMapCollector Collector; HeaderMapCollector Collector;
PragmaCommentHandler Handler; PragmaCommentHandler Handler;
FindAllSymbols Matcher; FindAllSymbols Matcher;
}; };
class FindAllSymbolsActionFactory : public tooling::FrontendActionFactory { class FindAllSymbolsActionFactory : public tooling::FrontendActionFactory {
public: public:
FindAllSymbolsActionFactory( FindAllSymbolsActionFactory(
SymbolReporter *Reporter, SymbolReporter *Reporter,
const HeaderMapCollector::HeaderMap *PostfixMap = nullptr) const HeaderMapCollector::RegexHeaderMap *RegexHeaderMap = nullptr)
: Reporter(Reporter), PostfixMap(PostfixMap) {} : Reporter(Reporter), RegexHeaderMap(RegexHeaderMap) {}
virtual clang::FrontendAction *create() override { virtual clang::FrontendAction *create() override {
return new FindAllSymbolsAction(Reporter, PostfixMap); return new FindAllSymbolsAction(Reporter, RegexHeaderMap);
} }
private: private:
SymbolReporter *const Reporter; SymbolReporter *const Reporter;
const HeaderMapCollector::HeaderMap *const PostfixMap; const HeaderMapCollector::RegexHeaderMap *const RegexHeaderMap;
}; };
} // namespace find_all_symbols } // namespace find_all_symbols
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_FIND_ALL_SYMBOLS_ACTION_H #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_FIND_ALL_SYMBOLS_ACTION_H

include-fixer/find-all-symbols/FindAllSymbolsAction.cpp

//===-- FindAllSymbolsAction.cpp - find all symbols action --------*- C++ -*-===// //===-- FindAllSymbolsAction.cpp - find all symbols action --------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FindAllSymbolsAction.h" #include "FindAllSymbolsAction.h"
namespace clang { namespace clang {
namespace find_all_symbols { namespace find_all_symbols {
FindAllSymbolsAction::FindAllSymbolsAction( FindAllSymbolsAction::FindAllSymbolsAction(
SymbolReporter *Reporter, const HeaderMapCollector::HeaderMap *PostfixMap) SymbolReporter *Reporter,
: Reporter(Reporter), Collector(PostfixMap), Handler(&Collector), const HeaderMapCollector::RegexHeaderMap *RegexHeaderMap)
: Reporter(Reporter), Collector(RegexHeaderMap), Handler(&Collector),
Matcher(Reporter, &Collector) { Matcher(Reporter, &Collector) {
Matcher.registerMatchers(&MatchFinder); Matcher.registerMatchers(&MatchFinder);
} }
std::unique_ptr<clang::ASTConsumer> std::unique_ptr<clang::ASTConsumer>
FindAllSymbolsAction::CreateASTConsumer(clang::CompilerInstance &Compiler, FindAllSymbolsAction::CreateASTConsumer(clang::CompilerInstance &Compiler,
StringRef InFile) { StringRef InFile) {
Compiler.getPreprocessor().addCommentHandler(&Handler); Compiler.getPreprocessor().addCommentHandler(&Handler);
Compiler.getPreprocessor().addPPCallbacks(llvm::make_unique<FindAllMacros>( Compiler.getPreprocessor().addPPCallbacks(llvm::make_unique<FindAllMacros>(
Reporter, &Compiler.getSourceManager(), &Collector)); Reporter, &Compiler.getSourceManager(), &Collector));
return MatchFinder.newASTConsumer(); return MatchFinder.newASTConsumer();
} }
} // namespace find_all_symbols } // namespace find_all_symbols
} // namespace clang } // namespace clang

include-fixer/find-all-symbols/HeaderMapCollector.h

//===-- HeaderMapCoolector.h - find all symbols------------------*- C++ -*-===// //===-- HeaderMapCoolector.h - find all symbols------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_HEADER_MAP_COLLECTOR_H #ifndef LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_HEADER_MAP_COLLECTOR_H
#define LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_HEADER_MAP_COLLECTOR_H #define LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_HEADER_MAP_COLLECTOR_H
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
#include "llvm/Support/Regex.h"
#include <string> #include <string>
namespace clang { namespace clang {
namespace find_all_symbols { namespace find_all_symbols {
/// \brief HeaderMappCollector collects all remapping header files. This maps /// \brief HeaderMappCollector collects all remapping header files. This maps
/// complete header names or postfixes of header names to header names. /// complete header names or header name regex patterns to header names.
class HeaderMapCollector { class HeaderMapCollector {
public: public:
typedef llvm::StringMap<std::string> HeaderMap; typedef llvm::StringMap<std::string> HeaderMap;
typedef std::vector<std::pair<llvm::StringRef, llvm::StringRef>>
RegexHeaderMap;
HeaderMapCollector() : PostfixMappingTable(nullptr) {} HeaderMapCollector() : RegexHeaderMappingTable(nullptr) {}
explicit HeaderMapCollector(const HeaderMap *PostfixMap) explicit HeaderMapCollector(const RegexHeaderMap *RegexHeaderMappingTable)
: PostfixMappingTable(PostfixMap) {} : RegexHeaderMappingTable(RegexHeaderMappingTable) {}
void addHeaderMapping(llvm::StringRef OrignalHeaderPath, void addHeaderMapping(llvm::StringRef OrignalHeaderPath,
llvm::StringRef MappingHeaderPath) { llvm::StringRef MappingHeaderPath) {
HeaderMappingTable[OrignalHeaderPath] = MappingHeaderPath; HeaderMappingTable[OrignalHeaderPath] = MappingHeaderPath;
}; };
/// Check if there is a mapping from \p Header or its postfix to another /// Check if there is a mapping from \p Header or a regex pattern that matches
/// header name. /// it to another header name.
/// \param Header A header name. /// \param Header A header name.
/// \return \p Header itself if there is no mapping for it; otherwise, return /// \return \p Header itself if there is no mapping for it; otherwise, return
/// a mapped header name. /// a mapped header name.
llvm::StringRef getMappedHeader(llvm::StringRef Header) const; llvm::StringRef getMappedHeader(llvm::StringRef Header) const;
private: private:
/// A string-to-string map saving the mapping relationship. /// A string-to-string map saving the mapping relationship.
HeaderMap HeaderMappingTable; HeaderMap HeaderMappingTable;
// A postfix-to-header name map. // A map from header patterns to header names.
// This is a reference to a hard-coded map. // This is a reference to a hard-coded map.
const HeaderMap *const PostfixMappingTable; const RegexHeaderMap *const RegexHeaderMappingTable;
}; };
} // namespace find_all_symbols } // namespace find_all_symbols
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_HEADER_MAP_COLLECTOR_H #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_HEADER_MAP_COLLECTOR_H

include-fixer/find-all-symbols/HeaderMapCollector.cpp

//===-- HeaderMapCoolector.h - find all symbols------------------*- C++ -*-===// //===-- HeaderMapCoolector.h - find all symbols------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "HeaderMapCollector.h" #include "HeaderMapCollector.h"
#include "llvm/Support/Regex.h"
namespace clang { namespace clang {
namespace find_all_symbols { namespace find_all_symbols {
llvm::StringRef llvm::StringRef
HeaderMapCollector::getMappedHeader(llvm::StringRef Header) const { HeaderMapCollector::getMappedHeader(llvm::StringRef Header) const {
auto Iter = HeaderMappingTable.find(Header); auto Iter = HeaderMappingTable.find(Header);
if (Iter != HeaderMappingTable.end()) if (Iter != HeaderMappingTable.end())
return Iter->second; return Iter->second;
// If there is no complete header name mapping for this header, check the // If there is no complete header name mapping for this header, check the
// postfix mapping. // regex header mapping.
// FIXME: this is not very efficient. Change PostfixMappingTable to use if (RegexHeaderMappingTable) {
// postfix tree if necessary. for (const auto &Entry : *RegexHeaderMappingTable) {
if (PostfixMappingTable) { if (llvm::Regex(Entry.first).match(Header))
for (const auto &Entry : *PostfixMappingTable) {
if (Header.endswith(Entry.first()))
return Entry.second; return Entry.second;
} }
} }
return Header; return Header;
} }
} // namespace find_all_symbols } // namespace find_all_symbols
} // namespace clang } // namespace clang

include-fixer/find-all-symbols/STLPostfixHeaderMap.h

Show All 9 Lines
#ifndef LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_TOOL_STL_POSTFIX_HEADER_MAP_H #ifndef LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_TOOL_STL_POSTFIX_HEADER_MAP_H
#define LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_TOOL_STL_POSTFIX_HEADER_MAP_H #define LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_TOOL_STL_POSTFIX_HEADER_MAP_H
#include "HeaderMapCollector.h" #include "HeaderMapCollector.h"
namespace clang { namespace clang {
namespace find_all_symbols { namespace find_all_symbols {
const HeaderMapCollector::HeaderMap* getSTLPostfixHeaderMap(); const HeaderMapCollector::RegexHeaderMap *getSTLPostfixHeaderMap();
} // namespace find_all_symbols } // namespace find_all_symbols
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_TOOL_STL_POSTFIX_HEADER_MAP_H #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_TOOL_STL_POSTFIX_HEADER_MAP_H

include-fixer/find-all-symbols/STLPostfixHeaderMap.cpp

//===-- STLPostfixHeaderMap.h - hardcoded STL header map --------*- C++ -*-===// //===-- STLPostfixHeaderMap.h - hardcoded STL header map --------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "STLPostfixHeaderMap.h" #include "STLPostfixHeaderMap.h"
namespace clang { namespace clang {
namespace find_all_symbols { namespace find_all_symbols {
const HeaderMapCollector::HeaderMap *getSTLPostfixHeaderMap() { const HeaderMapCollector::RegexHeaderMap *getSTLPostfixHeaderMap() {
bkramerUnsubmitted
Done
ReplyInline Actions

Can we make this a std::vector<std::pair<llvm::Regex, const char *>>? Creating llvm::Regex is somewhat expensive so we only want to do it once. We also never lookup into the postfix header map and only iterate over it so using a StringMap for it is wasteful.

bkramer: Can we make this a std::vector<std::pair<llvm::Regex, const char *>>? Creating llvm::Regex is…
ioericAuthorUnsubmitted
Not Done
ReplyInline Actions

As per our offline discussion, copy constructor of llvm::Regex is deleted and the non-const match function prevents us from making the header map const. So we use std::vector<std::pair<StringRef, StringRef>> instead.

ioeric: As per our offline discussion, copy constructor of `llvm::Regex` is deleted and the non-const…
static const HeaderMapCollector::HeaderMap STLPostfixHeaderMap = { static const HeaderMapCollector::RegexHeaderMap STLPostfixHeaderMap = {
{"include/__stddef_max_align_t.h", "<cstddef>"}, {"include/__stddef_max_align_t.h$", "<cstddef>"},
{"include/__wmmintrin_aes.h", "<wmmintrin.h>"}, {"include/__wmmintrin_aes.h$", "<wmmintrin.h>"},
{"include/__wmmintrin_pclmul.h", "<wmmintrin.h>"}, {"include/__wmmintrin_pclmul.h$", "<wmmintrin.h>"},
{"include/adxintrin.h", "<immintrin.h>"}, {"include/adxintrin.h$", "<immintrin.h>"},
{"include/ammintrin.h", "<ammintrin.h>"}, {"include/ammintrin.h$", "<ammintrin.h>"},
{"include/avx2intrin.h", "<immintrin.h>"}, {"include/avx2intrin.h$", "<immintrin.h>"},
{"include/avx512bwintrin.h", "<immintrin.h>"}, {"include/avx512bwintrin.h$", "<immintrin.h>"},
{"include/avx512cdintrin.h", "<immintrin.h>"}, {"include/avx512cdintrin.h$", "<immintrin.h>"},
{"include/avx512dqintrin.h", "<immintrin.h>"}, {"include/avx512dqintrin.h$", "<immintrin.h>"},
{"include/avx512erintrin.h", "<immintrin.h>"}, {"include/avx512erintrin.h$", "<immintrin.h>"},
{"include/avx512fintrin.h", "<immintrin.h>"}, {"include/avx512fintrin.h$", "<immintrin.h>"},
{"include/avx512ifmaintrin.h", "<immintrin.h>"}, {"include/avx512ifmaintrin.h$", "<immintrin.h>"},
{"include/avx512ifmavlintrin.h", "<immintrin.h>"}, {"include/avx512ifmavlintrin.h$", "<immintrin.h>"},
{"include/avx512pfintrin.h", "<immintrin.h>"}, {"include/avx512pfintrin.h$", "<immintrin.h>"},
{"include/avx512vbmiintrin.h", "<immintrin.h>"}, {"include/avx512vbmiintrin.h$", "<immintrin.h>"},
{"include/avx512vbmivlintrin.h", "<immintrin.h>"}, {"include/avx512vbmivlintrin.h$", "<immintrin.h>"},
{"include/avx512vlbwintrin.h", "<immintrin.h>"}, {"include/avx512vlbwintrin.h$", "<immintrin.h>"},
{"include/avx512vlcdintrin.h", "<immintrin.h>"}, {"include/avx512vlcdintrin.h$", "<immintrin.h>"},
{"include/avx512vldqintrin.h", "<immintrin.h>"}, {"include/avx512vldqintrin.h$", "<immintrin.h>"},
{"include/avx512vlintrin.h", "<immintrin.h>"}, {"include/avx512vlintrin.h$", "<immintrin.h>"},
{"include/avxintrin.h", "<immintrin.h>"}, {"include/avxintrin.h$", "<immintrin.h>"},
{"include/bmi2intrin.h", "<x86intrin.h>"}, {"include/bmi2intrin.h$", "<x86intrin.h>"},
{"include/bmiintrin.h", "<x86intrin.h>"}, {"include/bmiintrin.h$", "<x86intrin.h>"},
{"include/emmintrin.h", "<emmintrin.h>"}, {"include/emmintrin.h$", "<emmintrin.h>"},
{"include/f16cintrin.h", "<emmintrin.h>"}, {"include/f16cintrin.h$", "<emmintrin.h>"},
{"include/float.h", "<cfloat>"}, {"include/float.h$", "<cfloat>"},
{"include/fma4intrin.h", "<x86intrin.h>"}, {"include/fma4intrin.h$", "<x86intrin.h>"},
{"include/fmaintrin.h", "<immintrin.h>"}, {"include/fmaintrin.h$", "<immintrin.h>"},
{"include/fxsrintrin.h", "<immintrin.h>"}, {"include/fxsrintrin.h$", "<immintrin.h>"},
{"include/ia32intrin.h", "<x86intrin.h>"}, {"include/ia32intrin.h$", "<x86intrin.h>"},
{"include/immintrin.h", "<immintrin.h>"}, {"include/immintrin.h$", "<immintrin.h>"},
{"include/inttypes.h", "<cinttypes>"}, {"include/inttypes.h$", "<cinttypes>"},
{"include/limits.h", "<climits>"}, {"include/limits.h$", "<climits>"},
{"include/lzcntintrin.h", "<x86intrin.h>"}, {"include/lzcntintrin.h$", "<x86intrin.h>"},
{"include/mm3dnow.h", "<mm3dnow.h>"}, {"include/mm3dnow.h$", "<mm3dnow.h>"},
{"include/mm_malloc.h", "<mm_malloc.h>"}, {"include/mm_malloc.h$", "<mm_malloc.h>"},
{"include/mmintrin.h", "<mmintrin>"}, {"include/mmintrin.h$", "<mmintrin>"},
{"include/mwaitxintrin.h", "<x86intrin.h>"}, {"include/mwaitxintrin.h$", "<x86intrin.h>"},
{"include/pkuintrin.h", "<immintrin.h>"}, {"include/pkuintrin.h$", "<immintrin.h>"},
{"include/pmmintrin.h", "<pmmintrin.h>"}, {"include/pmmintrin.h$", "<pmmintrin.h>"},
{"include/popcntintrin.h", "<popcntintrin.h>"}, {"include/popcntintrin.h$", "<popcntintrin.h>"},
{"include/prfchwintrin.h", "<x86intrin.h>"}, {"include/prfchwintrin.h$", "<x86intrin.h>"},
{"include/rdseedintrin.h", "<x86intrin.h>"}, {"include/rdseedintrin.h$", "<x86intrin.h>"},
{"include/rtmintrin.h", "<immintrin.h>"}, {"include/rtmintrin.h$", "<immintrin.h>"},
{"include/shaintrin.h", "<immintrin.h>"}, {"include/shaintrin.h$", "<immintrin.h>"},
{"include/smmintrin.h", "<smmintrin.h>"}, {"include/smmintrin.h$", "<smmintrin.h>"},
{"include/stdalign.h", "<cstdalign>"}, {"include/stdalign.h$", "<cstdalign>"},
{"include/stdarg.h", "<cstdarg>"}, {"include/stdarg.h$", "<cstdarg>"},
{"include/stdbool.h", "<cstdbool>"}, {"include/stdbool.h$", "<cstdbool>"},
{"include/stddef.h", "<cstddef>"}, {"include/stddef.h$", "<cstddef>"},
{"include/stdint.h", "<cstdint>"}, {"include/stdint.h$", "<cstdint>"},
{"include/tbmintrin.h", "<x86intrin.h>"}, {"include/tbmintrin.h$", "<x86intrin.h>"},
{"include/tmmintrin.h", "<tmmintrin.h>"}, {"include/tmmintrin.h$", "<tmmintrin.h>"},
{"include/wmmintrin.h", "<wmmintrin.h>"}, {"include/wmmintrin.h$", "<wmmintrin.h>"},
{"include/x86intrin.h", "<x86intrin.h>"}, {"include/x86intrin.h$", "<x86intrin.h>"},
{"include/xmmintrin.h", "<xmmintrin.h>"}, {"include/xmmintrin.h$", "<xmmintrin.h>"},
{"include/xopintrin.h", "<x86intrin.h>"}, {"include/xopintrin.h$", "<x86intrin.h>"},
{"include/xsavecintrin.h", "<immintrin.h>"}, {"include/xsavecintrin.h$", "<immintrin.h>"},
{"include/xsaveintrin.h", "<immintrin.h>"}, {"include/xsaveintrin.h$", "<immintrin.h>"},
{"include/xsaveoptintrin.h", "<immintrin.h>"}, {"include/xsaveoptintrin.h$", "<immintrin.h>"},
{"include/xsavesintrin.h", "<immintrin.h>"}, {"include/xsavesintrin.h$", "<immintrin.h>"},
{"include/xtestintrin.h", "<immintrin.h>"}, {"include/xtestintrin.h$", "<immintrin.h>"},
{"include/_G_config.h", "<cstdio>"}, {"include/_G_config.h$", "<cstdio>"},
{"include/assert.h", "<cassert>"}, {"include/assert.h$", "<cassert>"},
{"algorithm", "<algorithm>"}, {"algorithm$", "<algorithm>"},
{"array", "<array>"}, {"array$", "<array>"},
{"atomic", "<atomic>"}, {"atomic$", "<atomic>"},
{"backward/auto_ptr.h", "<memory>"}, {"backward/auto_ptr.h$", "<memory>"},
{"backward/binders.h", "<string>"}, {"backward/binders.h$", "<string>"},
{"bits/algorithmfwd.h", "<algorithm>"}, {"bits/algorithmfwd.h$", "<algorithm>"},
{"bits/alloc_traits.h", "<unordered_set>"}, {"bits/alloc_traits.h$", "<unordered_set>"},
{"bits/allocator.h", "<string>"}, {"bits/allocator.h$", "<string>"},
{"bits/atomic_base.h", "<atomic>"}, {"bits/atomic_base.h$", "<atomic>"},
{"bits/atomic_lockfree_defines.h", "<exception>"}, {"bits/atomic_lockfree_defines.h$", "<exception>"},
{"bits/basic_ios.h", "<ios>"}, {"bits/basic_ios.h$", "<ios>"},
{"bits/basic_ios.tcc", "<ios>"}, {"bits/basic_ios.tcc$", "<ios>"},
{"bits/basic_string.h", "<string>"}, {"bits/basic_string.h$", "<string>"},
{"bits/basic_string.tcc", "<string>"}, {"bits/basic_string.tcc$", "<string>"},
{"bits/char_traits.h", "<string>"}, {"bits/char_traits.h$", "<string>"},
{"bits/codecvt.h", "<fstream>"}, {"bits/codecvt.h$", "<fstream>"},
{"bits/concept_check.h", "<numeric>"}, {"bits/concept_check.h$", "<numeric>"},
{"bits/cpp_type_traits.h", "<cmath>"}, {"bits/cpp_type_traits.h$", "<cmath>"},
{"bits/cxxabi_forced.h", "<cxxabi.h>"}, {"bits/cxxabi_forced.h$", "<cxxabi.h>"},
{"bits/deque.tcc", "<deque>"}, {"bits/deque.tcc$", "<deque>"},
{"bits/exception_defines.h", "<exception>"}, {"bits/exception_defines.h$", "<exception>"},
{"bits/exception_ptr.h", "<exception>"}, {"bits/exception_ptr.h$", "<exception>"},
{"bits/forward_list.h", "<forward_list>"}, {"bits/forward_list.h$", "<forward_list>"},
{"bits/forward_list.tcc", "<forward_list>"}, {"bits/forward_list.tcc$", "<forward_list>"},
{"bits/fstream.tcc", "<fstream>"}, {"bits/fstream.tcc$", "<fstream>"},
{"bits/functexcept.h", "<list>"}, {"bits/functexcept.h$", "<list>"},
{"bits/functional_hash.h", "<string>"}, {"bits/functional_hash.h$", "<string>"},
{"bits/gslice.h", "<valarray>"}, {"bits/gslice.h$", "<valarray>"},
{"bits/gslice_array.h", "<valarray>"}, {"bits/gslice_array.h$", "<valarray>"},
{"bits/hash_bytes.h", "<typeinfo>"}, {"bits/hash_bytes.h$", "<typeinfo>"},
{"bits/hashtable.h", "<unordered_set>"}, {"bits/hashtable.h$", "<unordered_set>"},
{"bits/hashtable_policy.h", "<unordered_set>"}, {"bits/hashtable_policy.h$", "<unordered_set>"},
{"bits/indirect_array.h", "<valarray>"}, {"bits/indirect_array.h$", "<valarray>"},
{"bits/ios_base.h", "<ios>"}, {"bits/ios_base.h$", "<ios>"},
{"bits/istream.tcc", "<istream>"}, {"bits/istream.tcc$", "<istream>"},
{"bits/list.tcc", "<list>"}, {"bits/list.tcc$", "<list>"},
{"bits/locale_classes.h", "<locale>"}, {"bits/locale_classes.h$", "<locale>"},
{"bits/locale_classes.tcc", "<locale>"}, {"bits/locale_classes.tcc$", "<locale>"},
{"bits/locale_facets.h", "<locale>"}, {"bits/locale_facets.h$", "<locale>"},
{"bits/locale_facets.tcc", "<locale>"}, {"bits/locale_facets.tcc$", "<locale>"},
{"bits/locale_facets_nonio.h", "<locale>"}, {"bits/locale_facets_nonio.h$", "<locale>"},
{"bits/locale_facets_nonio.tcc", "<locale>"}, {"bits/locale_facets_nonio.tcc$", "<locale>"},
{"bits/localefwd.h", "<string>"}, {"bits/localefwd.h$", "<string>"},
{"bits/mask_array.h", "<valarray>"}, {"bits/mask_array.h$", "<valarray>"},
{"bits/memoryfwd.h", "<string>"}, {"bits/memoryfwd.h$", "<string>"},
{"bits/move.h", "<utility>"}, {"bits/move.h$", "<utility>"},
{"bits/nested_exception.h", "<exception>"}, {"bits/nested_exception.h$", "<exception>"},
{"bits/ostream.tcc", "<ostream>"}, {"bits/ostream.tcc$", "<ostream>"},
{"bits/ostream_insert.h", "<string>"}, {"bits/ostream_insert.h$", "<string>"},
{"bits/postypes.h", "<iosfwd>"}, {"bits/postypes.h$", "<iosfwd>"},
{"bits/ptr_traits.h", "<unordered_set>"}, {"bits/ptr_traits.h$", "<unordered_set>"},
{"bits/random.h", "<random>"}, {"bits/random.h$", "<random>"},
{"bits/random.tcc", "<random>"}, {"bits/random.tcc$", "<random>"},
{"bits/range_access.h", "<string>"}, {"bits/range_access.h$", "<string>"},
{"bits/regex.h", "<regex>"}, {"bits/regex.h$", "<regex>"},
{"bits/regex_compiler.h", "<regex>"}, {"bits/regex_compiler.h$", "<regex>"},
{"bits/regex_constants.h", "<regex>"}, {"bits/regex_constants.h$", "<regex>"},
{"bits/regex_cursor.h", "<regex>"}, {"bits/regex_cursor.h$", "<regex>"},
{"bits/regex_error.h", "<regex>"}, {"bits/regex_error.h$", "<regex>"},
{"bits/regex_grep_matcher.h", "<regex>"}, {"bits/regex_grep_matcher.h$", "<regex>"},
{"bits/regex_grep_matcher.tcc", "<regex>"}, {"bits/regex_grep_matcher.tcc$", "<regex>"},
{"bits/regex_nfa.h", "<regex>"}, {"bits/regex_nfa.h$", "<regex>"},
{"bits/shared_ptr.h", "<memory>"}, {"bits/shared_ptr.h$", "<memory>"},
{"bits/shared_ptr_base.h", "<memory>"}, {"bits/shared_ptr_base.h$", "<memory>"},
{"bits/slice_array.h", "<valarray>"}, {"bits/slice_array.h$", "<valarray>"},
{"bits/sstream.tcc", "<sstream>"}, {"bits/sstream.tcc$", "<sstream>"},
{"bits/stl_algo.h", "<algorithm>"}, {"bits/stl_algo.h$", "<algorithm>"},
{"bits/stl_algobase.h", "<list>"}, {"bits/stl_algobase.h$", "<list>"},
{"bits/stl_bvector.h", "<vector>"}, {"bits/stl_bvector.h$", "<vector>"},
{"bits/stl_construct.h", "<deque>"}, {"bits/stl_construct.h$", "<deque>"},
{"bits/stl_deque.h", "<deque>"}, {"bits/stl_deque.h$", "<deque>"},
{"bits/stl_function.h", "<string>"}, {"bits/stl_function.h$", "<string>"},
{"bits/stl_heap.h", "<queue>"}, {"bits/stl_heap.h$", "<queue>"},
{"bits/stl_iterator.h", "<iterator>"}, {"bits/stl_iterator.h$", "<iterator>"},
{"bits/stl_iterator_base_funcs.h", "<iterator>"}, {"bits/stl_iterator_base_funcs.h$", "<iterator>"},
{"bits/stl_iterator_base_types.h", "<numeric>"}, {"bits/stl_iterator_base_types.h$", "<numeric>"},
{"bits/stl_list.h", "<list>"}, {"bits/stl_list.h$", "<list>"},
{"bits/stl_map.h", "<map>"}, {"bits/stl_map.h$", "<map>"},
{"bits/stl_multimap.h", "<map>"}, {"bits/stl_multimap.h$", "<map>"},
{"bits/stl_multiset.h", "<set>"}, {"bits/stl_multiset.h$", "<set>"},
{"bits/stl_numeric.h", "<numeric>"}, {"bits/stl_numeric.h$", "<numeric>"},
{"bits/stl_pair.h", "<utility>"}, {"bits/stl_pair.h$", "<utility>"},
{"bits/stl_queue.h", "<queue>"}, {"bits/stl_queue.h$", "<queue>"},
{"bits/stl_raw_storage_iter.h", "<memory>"}, {"bits/stl_raw_storage_iter.h$", "<memory>"},
{"bits/stl_relops.h", "<utility>"}, {"bits/stl_relops.h$", "<utility>"},
{"bits/stl_set.h", "<set>"}, {"bits/stl_set.h$", "<set>"},
{"bits/stl_stack.h", "<stack>"}, {"bits/stl_stack.h$", "<stack>"},
{"bits/stl_tempbuf.h", "<memory>"}, {"bits/stl_tempbuf.h$", "<memory>"},
{"bits/stl_tree.h", "<map>"}, {"bits/stl_tree.h$", "<map>"},
{"bits/stl_uninitialized.h", "<deque>"}, {"bits/stl_uninitialized.h$", "<deque>"},
{"bits/stl_vector.h", "<vector>"}, {"bits/stl_vector.h$", "<vector>"},
{"bits/stream_iterator.h", "<iterator>"}, {"bits/stream_iterator.h$", "<iterator>"},
{"bits/streambuf.tcc", "<streambuf>"}, {"bits/streambuf.tcc$", "<streambuf>"},
{"bits/streambuf_iterator.h", "<iterator>"}, {"bits/streambuf_iterator.h$", "<iterator>"},
{"bits/stringfwd.h", "<string>"}, {"bits/stringfwd.h$", "<string>"},
{"bits/unique_ptr.h", "<memory>"}, {"bits/unique_ptr.h$", "<memory>"},
{"bits/unordered_map.h", "<unordered_map>"}, {"bits/unordered_map.h$", "<unordered_map>"},
{"bits/unordered_set.h", "<unordered_set>"}, {"bits/unordered_set.h$", "<unordered_set>"},
{"bits/uses_allocator.h", "<tuple>"}, {"bits/uses_allocator.h$", "<tuple>"},
{"bits/valarray_after.h", "<valarray>"}, {"bits/valarray_after.h$", "<valarray>"},
{"bits/valarray_array.h", "<valarray>"}, {"bits/valarray_array.h$", "<valarray>"},
{"bits/valarray_array.tcc", "<valarray>"}, {"bits/valarray_array.tcc$", "<valarray>"},
{"bits/valarray_before.h", "<valarray>"}, {"bits/valarray_before.h$", "<valarray>"},
{"bits/vector.tcc", "<vector>"}, {"bits/vector.tcc$", "<vector>"},
{"bitset", "<bitset>"}, {"bitset$", "<bitset>"},
{"ccomplex", "<ccomplex>"}, {"ccomplex$", "<ccomplex>"},
{"cctype", "<cctype>"}, {"cctype$", "<cctype>"},
{"cerrno", "<cerrno>"}, {"cerrno$", "<cerrno>"},
{"cfenv", "<cfenv>"}, {"cfenv$", "<cfenv>"},
{"cfloat", "<cfloat>"}, {"cfloat$", "<cfloat>"},
{"chrono", "<chrono>"}, {"chrono$", "<chrono>"},
{"cinttypes", "<cinttypes>"}, {"cinttypes$", "<cinttypes>"},
{"climits", "<climits>"}, {"climits$", "<climits>"},
{"clocale", "<clocale>"}, {"clocale$", "<clocale>"},
{"cmath", "<cmath>"}, {"cmath$", "<cmath>"},
{"complex", "<complex>"}, {"complex$", "<complex>"},
{"complex.h", "<complex.h>"}, {"complex.h$", "<complex.h>"},
{"condition_variable", "<condition_variable>"}, {"condition_variable$", "<condition_variable>"},
{"csetjmp", "<csetjmp>"}, {"csetjmp$", "<csetjmp>"},
{"csignal", "<csignal>"}, {"csignal$", "<csignal>"},
{"cstdalign", "<cstdalign>"}, {"cstdalign$", "<cstdalign>"},
{"cstdarg", "<cstdarg>"}, {"cstdarg$", "<cstdarg>"},
{"cstdbool", "<cstdbool>"}, {"cstdbool$", "<cstdbool>"},
{"cstdint", "<cstdint>"}, {"cstdint$", "<cstdint>"},
{"cstdio", "<cstdio>"}, {"cstdio$", "<cstdio>"},
{"cstdlib", "<cstdlib>"}, {"cstdlib$", "<cstdlib>"},
{"cstring", "<cstring>"}, {"cstring$", "<cstring>"},
{"ctgmath", "<ctgmath>"}, {"ctgmath$", "<ctgmath>"},
{"ctime", "<ctime>"}, {"ctime$", "<ctime>"},
{"cwchar", "<cwchar>"}, {"cwchar$", "<cwchar>"},
{"cwctype", "<cwctype>"}, {"cwctype$", "<cwctype>"},
{"cxxabi.h", "<cxxabi.h>"}, {"cxxabi.h$", "<cxxabi.h>"},
{"debug/debug.h", "<numeric>"}, {"debug/debug.h$", "<numeric>"},
{"deque", "<deque>"}, {"deque$", "<deque>"},
{"exception", "<exception>"}, {"exception$", "<exception>"},
{"ext/alloc_traits.h", "<deque>"}, {"ext/alloc_traits.h$", "<deque>"},
{"ext/atomicity.h", "<memory>"}, {"ext/atomicity.h$", "<memory>"},
{"ext/concurrence.h", "<memory>"}, {"ext/concurrence.h$", "<memory>"},
{"ext/new_allocator.h", "<string>"}, {"ext/new_allocator.h$", "<string>"},
{"ext/numeric_traits.h", "<list>"}, {"ext/numeric_traits.h$", "<list>"},
{"ext/string_conversions.h", "<string>"}, {"ext/string_conversions.h$", "<string>"},
{"ext/type_traits.h", "<cmath>"}, {"ext/type_traits.h$", "<cmath>"},
{"fenv.h", "<fenv.h>"}, {"fenv.h$", "<fenv.h>"},
{"forward_list", "<forward_list>"}, {"forward_list$", "<forward_list>"},
{"fstream", "<fstream>"}, {"fstream$", "<fstream>"},
{"functional", "<functional>"}, {"functional$", "<functional>"},
{"future", "<future>"}, {"future$", "<future>"},
{"initializer_list", "<initializer_list>"}, {"initializer_list$", "<initializer_list>"},
{"iomanip", "<iomanip>"}, {"iomanip$", "<iomanip>"},
{"ios", "<ios>"}, {"ios$", "<ios>"},
{"iosfwd", "<iosfwd>"}, {"iosfwd$", "<iosfwd>"},
{"iostream", "<iostream>"}, {"iostream$", "<iostream>"},
{"istream", "<istream>"}, {"istream$", "<istream>"},
{"iterator", "<iterator>"}, {"iterator$", "<iterator>"},
{"limits", "<limits>"}, {"limits$", "<limits>"},
{"list", "<list>"}, {"list$", "<list>"},
{"locale", "<locale>"}, {"locale$", "<locale>"},
{"map", "<map>"}, {"map$", "<map>"},
{"memory", "<memory>"}, {"memory$", "<memory>"},
{"mutex", "<mutex>"}, {"mutex$", "<mutex>"},
{"new", "<new>"}, {"new$", "<new>"},
{"numeric", "<numeric>"}, {"numeric$", "<numeric>"},
{"ostream", "<ostream>"}, {"ostream$", "<ostream>"},
{"queue", "<queue>"}, {"queue$", "<queue>"},
{"random", "<random>"}, {"random$", "<random>"},
{"ratio", "<ratio>"}, {"ratio$", "<ratio>"},
{"regex", "<regex>"}, {"regex$", "<regex>"},
{"scoped_allocator", "<scoped_allocator>"}, {"scoped_allocator$", "<scoped_allocator>"},
{"set", "<set>"}, {"set$", "<set>"},
{"sstream", "<sstream>"}, {"sstream$", "<sstream>"},
{"stack", "<stack>"}, {"stack$", "<stack>"},
{"stdexcept", "<stdexcept>"}, {"stdexcept$", "<stdexcept>"},
{"streambuf", "<streambuf>"}, {"streambuf$", "<streambuf>"},
{"string", "<string>"}, {"string$", "<string>"},
{"system_error", "<system_error>"}, {"system_error$", "<system_error>"},
{"tgmath.h", "<tgmath.h>"}, {"tgmath.h$", "<tgmath.h>"},
{"thread", "<thread>"}, {"thread$", "<thread>"},
{"tuple", "<tuple>"}, {"tuple$", "<tuple>"},
{"type_traits", "<type_traits>"}, {"type_traits$", "<type_traits>"},
{"typeindex", "<typeindex>"}, {"typeindex$", "<typeindex>"},
{"typeinfo", "<typeinfo>"}, {"typeinfo$", "<typeinfo>"},
{"unordered_map", "<unordered_map>"}, {"unordered_map$", "<unordered_map>"},
{"unordered_set", "<unordered_set>"}, {"unordered_set$", "<unordered_set>"},
{"utility", "<utility>"}, {"utility$", "<utility>"},
{"valarray", "<valarray>"}, {"valarray$", "<valarray>"},
{"vector", "<vector>"}, {"vector$", "<vector>"},
{"include/complex.h", "<complex.h>"}, {"include/complex.h$", "<complex.h>"},
{"include/ctype.h", "<cctype>"}, {"include/ctype.h$", "<cctype>"},
{"include/errno.h", "<cerrno>"}, {"include/errno.h$", "<cerrno>"},
{"include/fenv.h", "<fenv.h>"}, {"include/fenv.h$", "<fenv.h>"},
{"include/inttypes.h", "<cinttypes>"}, {"include/inttypes.h$", "<cinttypes>"},
{"include/libio.h", "<cstdio>"}, {"include/libio.h$", "<cstdio>"},
{"include/limits.h", "<climits>"}, {"include/limits.h$", "<climits>"},
{"include/locale.h", "<clocale>"}, {"include/locale.h$", "<clocale>"},
{"include/math.h", "<cmath>"}, {"include/math.h$", "<cmath>"},
{"include/setjmp.h", "<csetjmp>"}, {"include/setjmp.h$", "<csetjmp>"},
{"include/signal.h", "<csignal>"}, {"include/signal.h$", "<csignal>"},
{"include/stdint.h", "<cstdint>"}, {"include/stdint.h$", "<cstdint>"},
{"include/stdio.h", "<cstdio>"}, {"include/stdio.h$", "<cstdio>"},
{"include/stdlib.h", "<cstdlib>"}, {"include/stdlib.h$", "<cstdlib>"},
{"include/string.h", "<cstring>"}, {"include/string.h$", "<cstring>"},
{"include/time.h", "<ctime>"}, {"include/time.h$", "<ctime>"},
{"include/wchar.h", "<cwchar>"}, {"include/wchar.h$", "<cwchar>"},
{"include/wctype.h", "<cwctype>"}, {"include/wctype.h$", "<cwctype>"},
{"bits/cmathcalls.h", "<complex.h>"}, {"bits/cmathcalls.h$", "<complex.h>"},
{"bits/errno.h", "<cerrno>"}, {"bits/errno.h$", "<cerrno>"},
{"bits/fenv.h", "<fenv.h>"}, {"bits/fenv.h$", "<fenv.h>"},
{"bits/huge_val.h", "<cmath>"}, {"bits/huge_val.h$", "<cmath>"},
{"bits/huge_valf.h", "<cmath>"}, {"bits/huge_valf.h$", "<cmath>"},
{"bits/huge_vall.h", "<cmath>"}, {"bits/huge_vall.h$", "<cmath>"},
{"bits/inf.h", "<cmath>"}, {"bits/inf.h$", "<cmath>"},
{"bits/local_lim.h", "<climits>"}, {"bits/local_lim.h$", "<climits>"},
{"bits/locale.h", "<clocale>"}, {"bits/locale.h$", "<clocale>"},
{"bits/mathcalls.h", "<math.h>"}, {"bits/mathcalls.h$", "<math.h>"},
{"bits/mathdef.h", "<cmath>"}, {"bits/mathdef.h$", "<cmath>"},
{"bits/nan.h", "<cmath>"}, {"bits/nan.h$", "<cmath>"},
{"bits/posix1_lim.h", "<climits>"}, {"bits/posix1_lim.h$", "<climits>"},
{"bits/posix2_lim.h", "<climits>"}, {"bits/posix2_lim.h$", "<climits>"},
{"bits/setjmp.h", "<csetjmp>"}, {"bits/setjmp.h$", "<csetjmp>"},
{"bits/sigaction.h", "<csignal>"}, {"bits/sigaction.h$", "<csignal>"},
{"bits/sigcontext.h", "<csignal>"}, {"bits/sigcontext.h$", "<csignal>"},
{"bits/siginfo.h", "<csignal>"}, {"bits/siginfo.h$", "<csignal>"},
{"bits/signum.h", "<csignal>"}, {"bits/signum.h$", "<csignal>"},
{"bits/sigset.h", "<csignal>"}, {"bits/sigset.h$", "<csignal>"},
{"bits/sigstack.h", "<csignal>"}, {"bits/sigstack.h$", "<csignal>"},
{"bits/stdio_lim.h", "<cstdio>"}, {"bits/stdio_lim.h$", "<cstdio>"},
{"bits/sys_errlist.h", "<cstdio>"}, {"bits/sys_errlist.h$", "<cstdio>"},
{"bits/time.h", "<ctime>"}, {"bits/time.h$", "<ctime>"},
{"bits/timex.h", "<ctime>"}, {"bits/timex.h$", "<ctime>"},
{"bits/typesizes.h", "<cstdio>"}, {"bits/typesizes.h$", "<cstdio>"},
{"bits/wchar.h", "<cwchar>"}, {"bits/wchar.h$", "<cwchar>"},
{"bits/wordsize.h", "<csetjmp>"}, {"bits/wordsize.h$", "<csetjmp>"},
{"bits/xopen_lim.h", "<climits>"}, {"bits/xopen_lim.h$", "<climits>"},
{"include/xlocale.h", "<cstring>"}, {"include/xlocale.h$", "<cstring>"},
{"bits/atomic_word.h", "<memory>"}, {"bits/atomic_word.h$", "<memory>"},
{"bits/basic_file.h", "<fstream>"}, {"bits/basic_file.h$", "<fstream>"},
{"bits/c++allocator.h", "<string>"}, {"bits/c++allocator.h$", "<string>"},
{"bits/c++config.h", "<iosfwd>"}, {"bits/c++config.h$", "<iosfwd>"},
{"bits/c++io.h", "<fstream>"}, {"bits/c++io.h$", "<fstream>"},
{"bits/c++locale.h", "<string>"}, {"bits/c++locale.h$", "<string>"},
{"bits/cpu_defines.h", "<iosfwd>"}, {"bits/cpu_defines.h$", "<iosfwd>"},
{"bits/ctype_base.h", "<locale>"}, {"bits/ctype_base.h$", "<locale>"},
{"bits/cxxabi_tweaks.h", "<cxxabi.h>"}, {"bits/cxxabi_tweaks.h$", "<cxxabi.h>"},
{"bits/error_constants.h", "<system_error>"}, {"bits/error_constants.h$", "<system_error>"},
{"bits/gthr-default.h", "<memory>"}, {"bits/gthr-default.h$", "<memory>"},
{"bits/gthr.h", "<memory>"}, {"bits/gthr.h$", "<memory>"},
{"bits/opt_random.h", "<random>"}, {"bits/opt_random.h$", "<random>"},
{"bits/os_defines.h", "<iosfwd>"}, {"bits/os_defines.h$", "<iosfwd>"},
// GNU C headers // GNU C headers
{"include/aio.h", "<aio.h>"}, {"include/aio.h$", "<aio.h>"},
{"include/aliases.h", "<aliases.h>"}, {"include/aliases.h$", "<aliases.h>"},
{"include/alloca.h", "<alloca.h>"}, {"include/alloca.h$", "<alloca.h>"},
{"include/ar.h", "<ar.h>"}, {"include/ar.h$", "<ar.h>"},
{"include/argp.h", "<argp.h>"}, {"include/argp.h$", "<argp.h>"},
{"include/argz.h", "<argz.h>"}, {"include/argz.h$", "<argz.h>"},
{"include/arpa/nameser.h", "<resolv.h>"}, {"include/arpa/nameser.h$", "<resolv.h>"},
{"include/arpa/nameser_compat.h", "<resolv.h>"}, {"include/arpa/nameser_compat.h$", "<resolv.h>"},
{"include/byteswap.h", "<byteswap.h>"}, {"include/byteswap.h$", "<byteswap.h>"},
{"include/cpio.h", "<cpio.h>"}, {"include/cpio.h$", "<cpio.h>"},
{"include/crypt.h", "<crypt.h>"}, {"include/crypt.h$", "<crypt.h>"},
{"include/dirent.h", "<dirent.h>"}, {"include/dirent.h$", "<dirent.h>"},
{"include/dlfcn.h", "<dlfcn.h>"}, {"include/dlfcn.h$", "<dlfcn.h>"},
{"include/elf.h", "<elf.h>"}, {"include/elf.h$", "<elf.h>"},
{"include/endian.h", "<endian.h>"}, {"include/endian.h$", "<endian.h>"},
{"include/envz.h", "<envz.h>"}, {"include/envz.h$", "<envz.h>"},
{"include/err.h", "<err.h>"}, {"include/err.h$", "<err.h>"},
{"include/error.h", "<error.h>"}, {"include/error.h$", "<error.h>"},
{"include/execinfo.h", "<execinfo.h>"}, {"include/execinfo.h$", "<execinfo.h>"},
{"include/fcntl.h", "<fcntl.h>"}, {"include/fcntl.h$", "<fcntl.h>"},
{"include/features.h", "<features.h>"}, {"include/features.h$", "<features.h>"},
{"include/fenv.h", "<fenv.h>"}, {"include/fenv.h$", "<fenv.h>"},
{"include/fmtmsg.h", "<fmtmsg.h>"}, {"include/fmtmsg.h$", "<fmtmsg.h>"},
{"include/fnmatch.h", "<fnmatch.h>"}, {"include/fnmatch.h$", "<fnmatch.h>"},
{"include/fstab.h", "<fstab.h>"}, {"include/fstab.h$", "<fstab.h>"},
{"include/fts.h", "<fts.h>"}, {"include/fts.h$", "<fts.h>"},
{"include/ftw.h", "<ftw.h>"}, {"include/ftw.h$", "<ftw.h>"},
{"include/gconv.h", "<gconv.h>"}, {"include/gconv.h$", "<gconv.h>"},
{"include/getopt.h", "<getopt.h>"}, {"include/getopt.h$", "<getopt.h>"},
{"include/glob.h", "<glob.h>"}, {"include/glob.h$", "<glob.h>"},
{"include/grp.h", "<grp.h>"}, {"include/grp.h$", "<grp.h>"},
{"include/gshadow.h", "<gshadow.h>"}, {"include/gshadow.h$", "<gshadow.h>"},
{"include/iconv.h", "<iconv.h>"}, {"include/iconv.h$", "<iconv.h>"},
{"include/ifaddrs.h", "<ifaddrs.h>"}, {"include/ifaddrs.h$", "<ifaddrs.h>"},
{"include/kdb.h", "<kdb.h>"}, {"include/kdb.h$", "<kdb.h>"},
{"include/langinfo.h", "<langinfo.h>"}, {"include/langinfo.h$", "<langinfo.h>"},
{"include/libgen.h", "<libgen.h>"}, {"include/libgen.h$", "<libgen.h>"},
{"include/libintl.h", "<libintl.h>"}, {"include/libintl.h$", "<libintl.h>"},
{"include/link.h", "<link.h>"}, {"include/link.h$", "<link.h>"},
{"include/malloc.h", "<malloc.h>"}, {"include/malloc.h$", "<malloc.h>"},
{"include/mcheck.h", "<mcheck.h>"}, {"include/mcheck.h$", "<mcheck.h>"},
{"include/memory.h", "<memory.h>"}, {"include/memory.h$", "<memory.h>"},
{"include/mntent.h", "<mntent.h>"}, {"include/mntent.h$", "<mntent.h>"},
{"include/monetary.h", "<monetary.h>"}, {"include/monetary.h$", "<monetary.h>"},
{"include/mqueue.h", "<mqueue.h>"}, {"include/mqueue.h$", "<mqueue.h>"},
{"include/netdb.h", "<netdb.h>"}, {"include/netdb.h$", "<netdb.h>"},
{"include/netinet/in.h", "<netinet/in.h>"}, {"include/netinet/in.h$", "<netinet/in.h>"},
{"include/nl_types.h", "<nl_types.h>"}, {"include/nl_types.h$", "<nl_types.h>"},
{"include/nss.h", "<nss.h>"}, {"include/nss.h$", "<nss.h>"},
{"include/obstack.h", "<obstack.h>"}, {"include/obstack.h$", "<obstack.h>"},
{"include/panel.h", "<panel.h>"}, {"include/panel.h$", "<panel.h>"},
{"include/paths.h", "<paths.h>"}, {"include/paths.h$", "<paths.h>"},
{"include/printf.h", "<printf.h>"}, {"include/printf.h$", "<printf.h>"},
{"include/profile.h", "<profile.h>"}, {"include/profile.h$", "<profile.h>"},
{"include/pthread.h", "<pthread.h>"}, {"include/pthread.h$", "<pthread.h>"},
{"include/pty.h", "<pty.h>"}, {"include/pty.h$", "<pty.h>"},
{"include/pwd.h", "<pwd.h>"}, {"include/pwd.h$", "<pwd.h>"},
{"include/re_comp.h", "<re_comp.h>"}, {"include/re_comp.h$", "<re_comp.h>"},
{"include/regex.h", "<regex.h>"}, {"include/regex.h$", "<regex.h>"},
{"include/regexp.h", "<regexp.h>"}, {"include/regexp.h$", "<regexp.h>"},
{"include/resolv.h", "<resolv.h>"}, {"include/resolv.h$", "<resolv.h>"},
{"include/rpc/netdb.h", "<netdb.h>"}, {"include/rpc/netdb.h$", "<netdb.h>"},
{"include/sched.h", "<sched.h>"}, {"include/sched.h$", "<sched.h>"},
{"include/search.h", "<search.h>"}, {"include/search.h$", "<search.h>"},
{"include/semaphore.h", "<semaphore.h>"}, {"include/semaphore.h$", "<semaphore.h>"},
{"include/sgtty.h", "<sgtty.h>"}, {"include/sgtty.h$", "<sgtty.h>"},
{"include/shadow.h", "<shadow.h>"}, {"include/shadow.h$", "<shadow.h>"},
{"include/spawn.h", "<spawn.h>"}, {"include/spawn.h$", "<spawn.h>"},
{"include/stab.h", "<stab.h>"}, {"include/stab.h$", "<stab.h>"},
{"include/stdc-predef.h", "<stdc-predef.h>"}, {"include/stdc-predef.h$", "<stdc-predef.h>"},
{"include/stdio_ext.h", "<stdio_ext.h>"}, {"include/stdio_ext.h$", "<stdio_ext.h>"},
{"include/strings.h", "<strings.h>"}, {"include/strings.h$", "<strings.h>"},
{"include/stropts.h", "<stropts.h>"}, {"include/stropts.h$", "<stropts.h>"},
{"include/sudo_plugin.h", "<sudo_plugin.h>"}, {"include/sudo_plugin.h$", "<sudo_plugin.h>"},
{"include/sysexits.h", "<sysexits.h>"}, {"include/sysexits.h$", "<sysexits.h>"},
{"include/tar.h", "<tar.h>"}, {"include/tar.h$", "<tar.h>"},
{"include/tcpd.h", "<tcpd.h>"}, {"include/tcpd.h$", "<tcpd.h>"},
{"include/term.h", "<term.h>"}, {"include/term.h$", "<term.h>"},
{"include/term_entry.h", "<term_entry.h>"}, {"include/term_entry.h$", "<term_entry.h>"},
{"include/termcap.h", "<termcap.h>"}, {"include/termcap.h$", "<termcap.h>"},
{"include/termios.h", "<termios.h>"}, {"include/termios.h$", "<termios.h>"},
{"include/thread_db.h", "<thread_db.h>"}, {"include/thread_db.h$", "<thread_db.h>"},
{"include/tic.h", "<tic.h>"}, {"include/tic.h$", "<tic.h>"},
{"include/ttyent.h", "<ttyent.h>"}, {"include/ttyent.h$", "<ttyent.h>"},
{"include/uchar.h", "<uchar.h>"}, {"include/uchar.h$", "<uchar.h>"},
{"include/ucontext.h", "<ucontext.h>"}, {"include/ucontext.h$", "<ucontext.h>"},
{"include/ulimit.h", "<ulimit.h>"}, {"include/ulimit.h$", "<ulimit.h>"},
{"include/unctrl.h", "<unctrl.h>"}, {"include/unctrl.h$", "<unctrl.h>"},
{"include/unistd.h", "<unistd.h>"}, {"include/unistd.h$", "<unistd.h>"},
{"include/utime.h", "<utime.h>"}, {"include/utime.h$", "<utime.h>"},
{"include/utmp.h", "<utmp.h>"}, {"include/utmp.h$", "<utmp.h>"},
{"include/utmpx.h", "<utmpx.h>"}, {"include/utmpx.h$", "<utmpx.h>"},
{"include/values.h", "<values.h>"}, {"include/values.h$", "<values.h>"},
{"include/wordexp.h", "<wordexp.h>"}, {"include/wordexp.h$", "<wordexp.h>"},
{"fpu_control.h", "<fpu_control.h>"}, {"fpu_control.h$", "<fpu_control.h>"},
{"ieee754.h", "<ieee754.h>"}, {"ieee754.h$", "<ieee754.h>"},
{"include/xlocale.h", "<xlocale.h>"}, {"include/xlocale.h$", "<xlocale.h>"},
{"gnu/lib-names.h", "<gnu/lib-names.h>"}, {"gnu/lib-names.h$", "<gnu/lib-names.h>"},
{"gnu/libc-version.h", "<gnu/libc-version.h>"}, {"gnu/libc-version.h$", "<gnu/libc-version.h>"},
{"gnu/option-groups.h", "<gnu/option-groups.h>"}, {"gnu/option-groups.h$", "<gnu/option-groups.h>"},
{"gnu/stubs-32.h", "<gnu/stubs-32.h>"}, {"gnu/stubs-32.h$", "<gnu/stubs-32.h>"},
{"gnu/stubs-64.h", "<gnu/stubs-64.h>"}, {"gnu/stubs-64.h$", "<gnu/stubs-64.h>"},
{"gnu/stubs-x32.h", "<gnu/stubs-x32.h>"}, {"gnu/stubs-x32.h$", "<gnu/stubs-x32.h>"},
{"include/rpc/auth_des.h", "<rpc/auth_des.h>"}, {"include/rpc/auth_des.h$", "<rpc/auth_des.h>"},
{"include/rpc/rpc_msg.h", "<rpc/rpc_msg.h>"}, {"include/rpc/rpc_msg.h$", "<rpc/rpc_msg.h>"},
{"include/rpc/pmap_clnt.h", "<rpc/pmap_clnt.h>"}, {"include/rpc/pmap_clnt.h$", "<rpc/pmap_clnt.h>"},
{"include/rpc/rpc.h", "<rpc/rpc.h>"}, {"include/rpc/rpc.h$", "<rpc/rpc.h>"},
{"include/rpc/types.h", "<rpc/types.h>"}, {"include/rpc/types.h$", "<rpc/types.h>"},
{"include/rpc/auth_unix.h", "<rpc/auth_unix.h>"}, {"include/rpc/auth_unix.h$", "<rpc/auth_unix.h>"},
{"include/rpc/key_prot.h", "<rpc/key_prot.h>"}, {"include/rpc/key_prot.h$", "<rpc/key_prot.h>"},
{"include/rpc/pmap_prot.h", "<rpc/pmap_prot.h>"}, {"include/rpc/pmap_prot.h$", "<rpc/pmap_prot.h>"},
{"include/rpc/auth.h", "<rpc/auth.h>"}, {"include/rpc/auth.h$", "<rpc/auth.h>"},
{"include/rpc/svc_auth.h", "<rpc/svc_auth.h>"}, {"include/rpc/svc_auth.h$", "<rpc/svc_auth.h>"},
{"include/rpc/xdr.h", "<rpc/xdr.h>"}, {"include/rpc/xdr.h$", "<rpc/xdr.h>"},
{"include/rpc/pmap_rmt.h", "<rpc/pmap_rmt.h>"}, {"include/rpc/pmap_rmt.h$", "<rpc/pmap_rmt.h>"},
{"include/rpc/des_crypt.h", "<rpc/des_crypt.h>"}, {"include/rpc/des_crypt.h$", "<rpc/des_crypt.h>"},
{"include/rpc/svc.h", "<rpc/svc.h>"}, {"include/rpc/svc.h$", "<rpc/svc.h>"},
{"include/rpc/rpc_des.h", "<rpc/rpc_des.h>"}, {"include/rpc/rpc_des.h$", "<rpc/rpc_des.h>"},
{"include/rpc/clnt.h", "<rpc/clnt.h>"}, {"include/rpc/clnt.h$", "<rpc/clnt.h>"},
{"include/scsi/scsi.h", "<scsi/scsi.h>"}, {"include/scsi/scsi.h$", "<scsi/scsi.h>"},
{"include/scsi/sg.h", "<scsi/sg.h>"}, {"include/scsi/sg.h$", "<scsi/sg.h>"},
{"include/scsi/scsi_ioctl.h", "<scsi/scsi_ioctl>"}, {"include/scsi/scsi_ioctl.h$", "<scsi/scsi_ioctl>"},
{"include/netrose/rose.h", "<netrose/rose.h>"}, {"include/netrose/rose.h$", "<netrose/rose.h>"},
{"include/nfs/nfs.h", "<nfs/nfs.h>"}, {"include/nfs/nfs.h$", "<nfs/nfs.h>"},
{"include/netatalk/at.h", "<netatalk/at.h>"}, {"include/netatalk/at.h$", "<netatalk/at.h>"},
{"include/netinet/ether.h", "<netinet/ether.h>"}, {"include/netinet/ether.h$", "<netinet/ether.h>"},
{"include/netinet/icmp6.h", "<netinet/icmp6.h>"}, {"include/netinet/icmp6.h$", "<netinet/icmp6.h>"},
{"include/netinet/if_ether.h", "<netinet/if_ether.h>"}, {"include/netinet/if_ether.h$", "<netinet/if_ether.h>"},
{"include/netinet/if_fddi.h", "<netinet/if_fddi.h>"}, {"include/netinet/if_fddi.h$", "<netinet/if_fddi.h>"},
{"include/netinet/if_tr.h", "<netinet/if_tr.h>"}, {"include/netinet/if_tr.h$", "<netinet/if_tr.h>"},
{"include/netinet/igmp.h", "<netinet/igmp.h>"}, {"include/netinet/igmp.h$", "<netinet/igmp.h>"},
{"include/netinet/in.h", "<netinet/in.h>"}, {"include/netinet/in.h$", "<netinet/in.h>"},
{"include/netinet/in_systm.h", "<netinet/in_systm.h>"}, {"include/netinet/in_systm.h$", "<netinet/in_systm.h>"},
{"include/netinet/ip.h", "<netinet/ip.h>"}, {"include/netinet/ip.h$", "<netinet/ip.h>"},
{"include/netinet/ip6.h", "<netinet/ip6.h>"}, {"include/netinet/ip6.h$", "<netinet/ip6.h>"},
{"include/netinet/ip_icmp.h", "<netinet/ip_icmp.h>"}, {"include/netinet/ip_icmp.h$", "<netinet/ip_icmp.h>"},
{"include/netinet/tcp.h", "<netinet/tcp.h>"}, {"include/netinet/tcp.h$", "<netinet/tcp.h>"},
{"include/netinet/udp.h", "<netinet/udp.h>"}, {"include/netinet/udp.h$", "<netinet/udp.h>"},
{"include/netrom/netrom.h", "<netrom/netrom.h>"}, {"include/netrom/netrom.h$", "<netrom/netrom.h>"},
{"include/protocols/routed.h", "<protocols/routed.h>"}, {"include/protocols/routed.h$", "<protocols/routed.h>"},
{"include/protocols/rwhod.h", "<protocols/rwhod.h>"}, {"include/protocols/rwhod.h$", "<protocols/rwhod.h>"},
{"include/protocols/talkd.h", "<protocols/talkd.h>"}, {"include/protocols/talkd.h$", "<protocols/talkd.h>"},
{"include/protocols/timed.h", "<protocols/timed.h>"}, {"include/protocols/timed.h$", "<protocols/timed.h>"},
{"include/rpcsvc/klm_prot.x", "<rpcsvc/klm_prot.x>"}, {"include/rpcsvc/klm_prot.x$", "<rpcsvc/klm_prot.x>"},
{"include/rpcsvc/rstat.h", "<rpcsvc/rstat.h>"}, {"include/rpcsvc/rstat.h$", "<rpcsvc/rstat.h>"},
{"include/rpcsvc/spray.x", "<rpcsvc/spray.x>"}, {"include/rpcsvc/spray.x$", "<rpcsvc/spray.x>"},
{"include/rpcsvc/nlm_prot.x", "<rpcsvc/nlm_prot.x>"}, {"include/rpcsvc/nlm_prot.x$", "<rpcsvc/nlm_prot.x>"},
{"include/rpcsvc/nis_callback.x", "<rpcsvc/nis_callback.x>"}, {"include/rpcsvc/nis_callback.x$", "<rpcsvc/nis_callback.x>"},
{"include/rpcsvc/yp.h", "<rpcsvc/yp.h>"}, {"include/rpcsvc/yp.h$", "<rpcsvc/yp.h>"},
{"include/rpcsvc/yp.x", "<rpcsvc/yp.x>"}, {"include/rpcsvc/yp.x$", "<rpcsvc/yp.x>"},
{"include/rpcsvc/nfs_prot.h", "<rpcsvc/nfs_prot.h>"}, {"include/rpcsvc/nfs_prot.h$", "<rpcsvc/nfs_prot.h>"},
{"include/rpcsvc/rex.h", "<rpcsvc/rex.h>"}, {"include/rpcsvc/rex.h$", "<rpcsvc/rex.h>"},
{"include/rpcsvc/yppasswd.h", "<rpcsvc/yppasswd.h>"}, {"include/rpcsvc/yppasswd.h$", "<rpcsvc/yppasswd.h>"},
{"include/rpcsvc/rex.x", "<rpcsvc/rex.x>"}, {"include/rpcsvc/rex.x$", "<rpcsvc/rex.x>"},
{"include/rpcsvc/nis_tags.h", "<rpcsvc/nis_tags.h>"}, {"include/rpcsvc/nis_tags.h$", "<rpcsvc/nis_tags.h>"},
{"include/rpcsvc/nis_callback.h", "<rpcsvc/nis_callback.h>"}, {"include/rpcsvc/nis_callback.h$", "<rpcsvc/nis_callback.h>"},
{"include/rpcsvc/nfs_prot.x", "<rpcsvc/nfs_prot.x>"}, {"include/rpcsvc/nfs_prot.x$", "<rpcsvc/nfs_prot.x>"},
{"include/rpcsvc/bootparam_prot.x", "<rpcsvc/bootparam_prot.x>"}, {"include/rpcsvc/bootparam_prot.x$", "<rpcsvc/bootparam_prot.x>"},
{"include/rpcsvc/rusers.x", "<rpcsvc/rusers.x>"}, {"include/rpcsvc/rusers.x$", "<rpcsvc/rusers.x>"},
{"include/rpcsvc/rquota.x", "<rpcsvc/rquota.x>"}, {"include/rpcsvc/rquota.x$", "<rpcsvc/rquota.x>"},
{"include/rpcsvc/nis.h", "<rpcsvc/nis.h>"}, {"include/rpcsvc/nis.h$", "<rpcsvc/nis.h>"},
{"include/rpcsvc/nislib.h", "<rpcsvc/nislib.h>"}, {"include/rpcsvc/nislib.h$", "<rpcsvc/nislib.h>"},
{"include/rpcsvc/ypupd.h", "<rpcsvc/ypupd.h>"}, {"include/rpcsvc/ypupd.h$", "<rpcsvc/ypupd.h>"},
{"include/rpcsvc/bootparam.h", "<rpcsvc/bootparam.h>"}, {"include/rpcsvc/bootparam.h$", "<rpcsvc/bootparam.h>"},
{"include/rpcsvc/spray.h", "<rpcsvc/spray.h>"}, {"include/rpcsvc/spray.h$", "<rpcsvc/spray.h>"},
{"include/rpcsvc/key_prot.h", "<rpcsvc/key_prot.h>"}, {"include/rpcsvc/key_prot.h$", "<rpcsvc/key_prot.h>"},
{"include/rpcsvc/klm_prot.h", "<rpcsvc/klm_prot.h>"}, {"include/rpcsvc/klm_prot.h$", "<rpcsvc/klm_prot.h>"},
{"include/rpcsvc/sm_inter.h", "<rpcsvc/sm_inter.h>"}, {"include/rpcsvc/sm_inter.h$", "<rpcsvc/sm_inter.h>"},
{"include/rpcsvc/nlm_prot.h", "<rpcsvc/nlm_prot.h>"}, {"include/rpcsvc/nlm_prot.h$", "<rpcsvc/nlm_prot.h>"},
{"include/rpcsvc/yp_prot.h", "<rpcsvc/yp_prot.h>"}, {"include/rpcsvc/yp_prot.h$", "<rpcsvc/yp_prot.h>"},
{"include/rpcsvc/ypclnt.h", "<rpcsvc/ypclnt.h>"}, {"include/rpcsvc/ypclnt.h$", "<rpcsvc/ypclnt.h>"},
{"include/rpcsvc/rstat.x", "<rpcsvc/rstat.x>"}, {"include/rpcsvc/rstat.x$", "<rpcsvc/rstat.x>"},
{"include/rpcsvc/rusers.h", "<rpcsvc/rusers.h>"}, {"include/rpcsvc/rusers.h$", "<rpcsvc/rusers.h>"},
{"include/rpcsvc/key_prot.x", "<rpcsvc/key_prot.x>"}, {"include/rpcsvc/key_prot.x$", "<rpcsvc/key_prot.x>"},
{"include/rpcsvc/sm_inter.x", "<rpcsvc/sm_inter.x>"}, {"include/rpcsvc/sm_inter.x$", "<rpcsvc/sm_inter.x>"},
{"include/rpcsvc/rquota.h", "<rpcsvc/rquota.h>"}, {"include/rpcsvc/rquota.h$", "<rpcsvc/rquota.h>"},
{"include/rpcsvc/nis.x", "<rpcsvc/nis.x>"}, {"include/rpcsvc/nis.x$", "<rpcsvc/nis.x>"},
{"include/rpcsvc/bootparam_prot.h", "<rpcsvc/bootparam_prot.h>"}, {"include/rpcsvc/bootparam_prot.h$", "<rpcsvc/bootparam_prot.h>"},
{"include/rpcsvc/mount.h", "<rpcsvc/mount.h>"}, {"include/rpcsvc/mount.h$", "<rpcsvc/mount.h>"},
{"include/rpcsvc/mount.x", "<rpcsvc/mount.x>"}, {"include/rpcsvc/mount.x$", "<rpcsvc/mount.x>"},
{"include/rpcsvc/nis_object.x", "<rpcsvc/nis_object.x>"}, {"include/rpcsvc/nis_object.x$", "<rpcsvc/nis_object.x>"},
{"include/rpcsvc/yppasswd.x", "<rpcsvc/yppasswd.x>"}, {"include/rpcsvc/yppasswd.x$", "<rpcsvc/yppasswd.x>"},
{"sys/acct.h", "<sys/acct.h>"}, {"sys/acct.h$", "<sys/acct.h>"},
{"sys/auxv.h", "<sys/auxv.h>"}, {"sys/auxv.h$", "<sys/auxv.h>"},
{"sys/cdefs.h", "<sys/cdefs.h>"}, {"sys/cdefs.h$", "<sys/cdefs.h>"},
{"sys/debugreg.h", "<sys/debugreg.h>"}, {"sys/debugreg.h$", "<sys/debugreg.h>"},
{"sys/dir.h", "<sys/dir.h>"}, {"sys/dir.h$", "<sys/dir.h>"},
{"sys/elf.h", "<sys/elf.h>"}, {"sys/elf.h$", "<sys/elf.h>"},
{"sys/epoll.h", "<sys/epoll.h>"}, {"sys/epoll.h$", "<sys/epoll.h>"},
{"sys/eventfd.h", "<sys/eventfd.h>"}, {"sys/eventfd.h$", "<sys/eventfd.h>"},
{"sys/fanotify.h", "<sys/fanotify.h>"}, {"sys/fanotify.h$", "<sys/fanotify.h>"},
{"sys/file.h", "<sys/file.h>"}, {"sys/file.h$", "<sys/file.h>"},
{"sys/fsuid.h", "<sys/fsuid.h>"}, {"sys/fsuid.h$", "<sys/fsuid.h>"},
{"sys/gmon.h", "<sys/gmon.h>"}, {"sys/gmon.h$", "<sys/gmon.h>"},
{"sys/gmon_out.h", "<sys/gmon_out.h>"}, {"sys/gmon_out.h$", "<sys/gmon_out.h>"},
{"sys/inotify.h", "<sys/inotify.h>"}, {"sys/inotify.h$", "<sys/inotify.h>"},
{"sys/io.h", "<sys/io.h>"}, {"sys/io.h$", "<sys/io.h>"},
{"sys/ioctl.h", "<sys/ioctl.h>"}, {"sys/ioctl.h$", "<sys/ioctl.h>"},
{"sys/ipc.h", "<sys/ipc.h>"}, {"sys/ipc.h$", "<sys/ipc.h>"},
{"sys/kd.h", "<sys/kd.h>"}, {"sys/kd.h$", "<sys/kd.h>"},
{"sys/kdaemon.h", "<sys/kdaemon.h>"}, {"sys/kdaemon.h$", "<sys/kdaemon.h>"},
{"sys/klog.h", "<sys/klog.h>"}, {"sys/klog.h$", "<sys/klog.h>"},
{"sys/mman.h", "<sys/mman.h>"}, {"sys/mman.h$", "<sys/mman.h>"},
{"sys/mount.h", "<sys/mount.h>"}, {"sys/mount.h$", "<sys/mount.h>"},
{"sys/msg.h", "<sys/msg.h>"}, {"sys/msg.h$", "<sys/msg.h>"},
{"sys/mtio.h", "<sys/mtio.h>"}, {"sys/mtio.h$", "<sys/mtio.h>"},
{"sys/param.h", "<sys/param.h>"}, {"sys/param.h$", "<sys/param.h>"},
{"sys/pci.h", "<sys/pci.h>"}, {"sys/pci.h$", "<sys/pci.h>"},
{"sys/perm.h", "<sys/perm.h>"}, {"sys/perm.h$", "<sys/perm.h>"},
{"sys/personality.h", "<sys/personality.h>"}, {"sys/personality.h$", "<sys/personality.h>"},
{"sys/poll.h", "<sys/poll.h>"}, {"sys/poll.h$", "<sys/poll.h>"},
{"sys/prctl.h", "<sys/prctl.h>"}, {"sys/prctl.h$", "<sys/prctl.h>"},
{"sys/procfs.h", "<sys/procfs.h>"}, {"sys/procfs.h$", "<sys/procfs.h>"},
{"sys/profil.h", "<sys/profil.h>"}, {"sys/profil.h$", "<sys/profil.h>"},
{"sys/ptrace.h", "<sys/ptrace.h>"}, {"sys/ptrace.h$", "<sys/ptrace.h>"},
{"sys/queue.h", "<sys/queue.h>"}, {"sys/queue.h$", "<sys/queue.h>"},
{"sys/quota.h", "<sys/quota.h>"}, {"sys/quota.h$", "<sys/quota.h>"},
{"sys/raw.h", "<sys/raw.h>"}, {"sys/raw.h$", "<sys/raw.h>"},
{"sys/reboot.h", "<sys/reboot.h>"}, {"sys/reboot.h$", "<sys/reboot.h>"},
{"sys/reg.h", "<sys/reg.h>"}, {"sys/reg.h$", "<sys/reg.h>"},
{"sys/resource.h", "<sys/resource.h>"}, {"sys/resource.h$", "<sys/resource.h>"},
{"sys/select.h", "<sys/select.h>"}, {"sys/select.h$", "<sys/select.h>"},
{"sys/sem.h", "<sys/sem.h>"}, {"sys/sem.h$", "<sys/sem.h>"},
{"sys/sendfile.h", "<sys/sendfile.h>"}, {"sys/sendfile.h$", "<sys/sendfile.h>"},
{"sys/shm.h", "<sys/shm.h>"}, {"sys/shm.h$", "<sys/shm.h>"},
{"sys/signalfd.h", "<sys/signalfd.h>"}, {"sys/signalfd.h$", "<sys/signalfd.h>"},
{"sys/socket.h", "<sys/socket.h>"}, {"sys/socket.h$", "<sys/socket.h>"},
{"sys/stat.h", "<sys/stat.h>"}, {"sys/stat.h$", "<sys/stat.h>"},
{"sys/statfs.h", "<sys/statfs.h>"}, {"sys/statfs.h$", "<sys/statfs.h>"},
{"sys/statvfs.h", "<sys/statvfs.h>"}, {"sys/statvfs.h$", "<sys/statvfs.h>"},
{"sys/swap.h", "<sys/swap.h>"}, {"sys/swap.h$", "<sys/swap.h>"},
{"sys/syscall.h", "<sys/syscall.h>"}, {"sys/syscall.h$", "<sys/syscall.h>"},
{"sys/sysctl.h", "<sys/sysctl.h>"}, {"sys/sysctl.h$", "<sys/sysctl.h>"},
{"sys/sysinfo.h", "<sys/sysinfo.h>"}, {"sys/sysinfo.h$", "<sys/sysinfo.h>"},
{"sys/syslog.h", "<sys/syslog.h>"}, {"sys/syslog.h$", "<sys/syslog.h>"},
{"sys/sysmacros.h", "<sys/sysmacros.h>"}, {"sys/sysmacros.h$", "<sys/sysmacros.h>"},
{"sys/termios.h", "<sys/termios.h>"}, {"sys/termios.h$", "<sys/termios.h>"},
{"sys/time.h", "<sys/select.h>"}, {"sys/time.h$", "<sys/select.h>"},
{"sys/timeb.h", "<sys/timeb.h>"}, {"sys/timeb.h$", "<sys/timeb.h>"},
{"sys/timerfd.h", "<sys/timerfd.h>"}, {"sys/timerfd.h$", "<sys/timerfd.h>"},
{"sys/times.h", "<sys/times.h>"}, {"sys/times.h$", "<sys/times.h>"},
{"sys/timex.h", "<sys/timex.h>"}, {"sys/timex.h$", "<sys/timex.h>"},
{"sys/ttychars.h", "<sys/ttychars.h>"}, {"sys/ttychars.h$", "<sys/ttychars.h>"},
{"sys/ttydefaults.h", "<sys/ttydefaults.h>"}, {"sys/ttydefaults.h$", "<sys/ttydefaults.h>"},
{"sys/types.h", "<sys/types.h>"}, {"sys/types.h$", "<sys/types.h>"},
{"sys/ucontext.h", "<sys/ucontext.h>"}, {"sys/ucontext.h$", "<sys/ucontext.h>"},
{"sys/uio.h", "<sys/uio.h>"}, {"sys/uio.h$", "<sys/uio.h>"},
{"sys/un.h", "<sys/un.h>"}, {"sys/un.h$", "<sys/un.h>"},
{"sys/user.h", "<sys/user.h>"}, {"sys/user.h$", "<sys/user.h>"},
{"sys/ustat.h", "<sys/ustat.h>"}, {"sys/ustat.h$", "<sys/ustat.h>"},
{"sys/utsname.h", "<sys/utsname.h>"}, {"sys/utsname.h$", "<sys/utsname.h>"},
{"sys/vlimit.h", "<sys/vlimit.h>"}, {"sys/vlimit.h$", "<sys/vlimit.h>"},
{"sys/vm86.h", "<sys/vm86.h>"}, {"sys/vm86.h$", "<sys/vm86.h>"},
{"sys/vtimes.h", "<sys/vtimes.h>"}, {"sys/vtimes.h$", "<sys/vtimes.h>"},
{"sys/wait.h", "<sys/wait.h>"}, {"sys/wait.h$", "<sys/wait.h>"},
{"sys/xattr.h", "<sys/xattr.h>"}, {"sys/xattr.h$", "<sys/xattr.h>"},
{"bits/epoll.h", "<sys/epoll.h>"}, {"bits/epoll.h$", "<sys/epoll.h>"},
{"bits/eventfd.h", "<sys/eventfd.h>"}, {"bits/eventfd.h$", "<sys/eventfd.h>"},
{"bits/inotify.h", "<sys/inotify.h>"}, {"bits/inotify.h$", "<sys/inotify.h>"},
{"bits/ipc.h", "<sys/ipc.h>"}, {"bits/ipc.h$", "<sys/ipc.h>"},
{"bits/ipctypes.h", "<sys/ipc.h>"}, {"bits/ipctypes.h$", "<sys/ipc.h>"},
{"bits/mman-linux.h", "<sys/mman.h>"}, {"bits/mman-linux.h$", "<sys/mman.h>"},
{"bits/mman.h", "<sys/mman.h>"}, {"bits/mman.h$", "<sys/mman.h>"},
{"bits/msq.h", "<sys/msg.h>"}, {"bits/msq.h$", "<sys/msg.h>"},
{"bits/resource.h", "<sys/resource.h>"}, {"bits/resource.h$", "<sys/resource.h>"},
{"bits/sem.h", "<sys/sem.h>"}, {"bits/sem.h$", "<sys/sem.h>"},
{"bits/shm.h", "<sys/shm.h>"}, {"bits/shm.h$", "<sys/shm.h>"},
{"bits/signalfd.h", "<sys/signalfd.h>"}, {"bits/signalfd.h$", "<sys/signalfd.h>"},
{"bits/statfs.h", "<sys/statfs.h>"}, {"bits/statfs.h$", "<sys/statfs.h>"},
{"bits/statvfs.h", "<sys/statvfs.h>"}, {"bits/statvfs.h$", "<sys/statvfs.h>"},
{"bits/timerfd.h", "<sys/timerfd.h>"}, {"bits/timerfd.h$", "<sys/timerfd.h>"},
{"bits/utsname.h", "<sys/utsname.h>"}, {"bits/utsname.h$", "<sys/utsname.h>"},
{"bits/auxv.h", "<sys/auxv.h>"}, {"bits/auxv.h$", "<sys/auxv.h>"},
{"bits/byteswap-16.h", "<byteswap.h>"}, {"bits/byteswap-16.h$", "<byteswap.h>"},
{"bits/byteswap.h", "<byteswap.h>"}, {"bits/byteswap.h$", "<byteswap.h>"},
{"bits/confname.h", "<unistd.h>"}, {"bits/confname.h$", "<unistd.h>"},
{"bits/dirent.h", "<dirent.h>"}, {"bits/dirent.h$", "<dirent.h>"},
{"bits/dlfcn.h", "<dlfcn.h>"}, {"bits/dlfcn.h$", "<dlfcn.h>"},
{"bits/elfclass.h", "<link.h>"}, {"bits/elfclass.h$", "<link.h>"},
{"bits/endian.h", "<endian.h>"}, {"bits/endian.h$", "<endian.h>"},
{"bits/environments.h", "<unistd.h>"}, {"bits/environments.h$", "<unistd.h>"},
{"bits/fcntl-linux.h", "<fcntl.h>"}, {"bits/fcntl-linux.h$", "<fcntl.h>"},
{"bits/fcntl.h", "<fcntl.h>"}, {"bits/fcntl.h$", "<fcntl.h>"},
{"bits/in.h", "<netinet/in.h>"}, {"bits/in.h$", "<netinet/in.h>"},
{"bits/ioctl-types.h", "<sys/ioctl.h>"}, {"bits/ioctl-types.h$", "<sys/ioctl.h>"},
{"bits/ioctls.h", "<sys/ioctl.h>"}, {"bits/ioctls.h$", "<sys/ioctl.h>"},
{"bits/link.h", "<link.h>"}, {"bits/link.h$", "<link.h>"},
{"bits/mqueue.h", "<mqueue.h>"}, {"bits/mqueue.h$", "<mqueue.h>"},
{"bits/netdb.h", "<netdb.h>"}, {"bits/netdb.h$", "<netdb.h>"},
{"bits/param.h", "<sys/param.h>"}, {"bits/param.h$", "<sys/param.h>"},
{"bits/poll.h", "<sys/poll.h>"}, {"bits/poll.h$", "<sys/poll.h>"},
{"bits/posix_opt.h", "<bits/posix_opt.h>"}, {"bits/posix_opt.h$", "<bits/posix_opt.h>"},
{"bits/pthreadtypes.h", "<pthread.h>"}, {"bits/pthreadtypes.h$", "<pthread.h>"},
{"bits/sched.h", "<sched.h>"}, {"bits/sched.h$", "<sched.h>"},
{"bits/select.h", "<sys/select.h>"}, {"bits/select.h$", "<sys/select.h>"},
{"bits/semaphore.h", "<semaphore.h>"}, {"bits/semaphore.h$", "<semaphore.h>"},
{"bits/sigthread.h", "<pthread.h>"}, {"bits/sigthread.h$", "<pthread.h>"},
{"bits/sockaddr.h", "<sys/socket.h>"}, {"bits/sockaddr.h$", "<sys/socket.h>"},
{"bits/socket.h", "<sys/socket.h>"}, {"bits/socket.h$", "<sys/socket.h>"},
{"bits/socket_type.h", "<sys/socket.h>"}, {"bits/socket_type.h$", "<sys/socket.h>"},
{"bits/stab.def", "<stab.h>"}, {"bits/stab.def$", "<stab.h>"},
{"bits/stat.h", "<sys/stat.h>"}, {"bits/stat.h$", "<sys/stat.h>"},
{"bits/stropts.h", "<stropts.h>"}, {"bits/stropts.h$", "<stropts.h>"},
{"bits/syscall.h", "<sys/syscall.h>"}, {"bits/syscall.h$", "<sys/syscall.h>"},
{"bits/syslog-path.h", "<sys/syslog.h>"}, {"bits/syslog-path.h$", "<sys/syslog.h>"},
{"bits/termios.h", "<termios.h>"}, {"bits/termios.h$", "<termios.h>"},
{"bits/types.h", "<sys/types.h>"}, {"bits/types.h$", "<sys/types.h>"},
{"bits/typesizes.h", "<sys/types.h>"}, {"bits/typesizes.h$", "<sys/types.h>"},
{"bits/uio.h", "<sys/uio.h>"}, {"bits/uio.h$", "<sys/uio.h>"},
{"bits/ustat.h", "<sys/ustat.h>"}, {"bits/ustat.h$", "<sys/ustat.h>"},
{"bits/utmp.h", "<utmp.h>"}, {"bits/utmp.h$", "<utmp.h>"},
{"bits/utmpx.h", "<utmpx.h>"}, {"bits/utmpx.h$", "<utmpx.h>"},
{"bits/waitflags.h", "<sys/wait.h>"}, {"bits/waitflags.h$", "<sys/wait.h>"},
{"bits/waitstatus.h", "<sys/wait.h>"}, {"bits/waitstatus.h$", "<sys/wait.h>"},
{"bits/xtitypes.h", "<stropts.h>"}, {"bits/xtitypes.h$", "<stropts.h>"},
}; };
return &STLPostfixHeaderMap; return &STLPostfixHeaderMap;
} }
} // namespace find_all_symbols } // namespace find_all_symbols
} // namespace clang } // namespace clang

unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linespublic:
bool runFindAllSymbols(StringRef Code) { bool runFindAllSymbols(StringRef Code) {
llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem( llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
new vfs::InMemoryFileSystem); new vfs::InMemoryFileSystem);
llvm::IntrusiveRefCntPtr<FileManager> Files( llvm::IntrusiveRefCntPtr<FileManager> Files(
new FileManager(FileSystemOptions(), InMemoryFileSystem)); new FileManager(FileSystemOptions(), InMemoryFileSystem));
std::string FileName = "symbol.cc"; std::string FileName = "symbol.cc";
const std::string InternalHeader = "internal/internal.h"; const std::string InternalHeader = "internal/internal_header.h";
const std::string TopHeader = "<top>"; const std::string TopHeader = "<top>";
// Test .inc header path. The header for `IncHeaderClass` should be // Test .inc header path. The header for `IncHeaderClass` should be
// internal.h, which will eventually be mapped to <top>. // internal.h, which will eventually be mapped to <top>.
std::string IncHeader = "internal/private.inc"; std::string IncHeader = "internal/private.inc";
std::string IncHeaderCode = "class IncHeaderClass {};"; std::string IncHeaderCode = "class IncHeaderClass {};";
HeaderMapCollector::HeaderMap PostfixMap = { HeaderMapCollector::RegexHeaderMap RegexMap = {
{"internal.h", TopHeader}, {R"(internal_.*\.h$)", TopHeader},
}; };
std::string InternalCode = std::string InternalCode =
"#include \"private.inc\"\nclass Internal {};"; "#include \"private.inc\"\nclass Internal {};";
SymbolInfo InternalSymbol("Internal", SymbolInfo::SymbolKind::Class, SymbolInfo InternalSymbol("Internal", SymbolInfo::SymbolKind::Class,
TopHeader, 2, {}); TopHeader, 2, {});
SymbolInfo IncSymbol("IncHeaderClass", SymbolInfo::SymbolKind::Class, SymbolInfo IncSymbol("IncHeaderClass", SymbolInfo::SymbolKind::Class,
TopHeader, 1, {}); TopHeader, 1, {});
InMemoryFileSystem->addFile( InMemoryFileSystem->addFile(
IncHeader, 0, llvm::MemoryBuffer::getMemBuffer(IncHeaderCode)); IncHeader, 0, llvm::MemoryBuffer::getMemBuffer(IncHeaderCode));
InMemoryFileSystem->addFile(InternalHeader, 0, InMemoryFileSystem->addFile(InternalHeader, 0,
llvm::MemoryBuffer::getMemBuffer(InternalCode)); llvm::MemoryBuffer::getMemBuffer(InternalCode));
std::unique_ptr<clang::tooling::FrontendActionFactory> Factory( std::unique_ptr<clang::tooling::FrontendActionFactory> Factory(
new FindAllSymbolsActionFactory(&Reporter, &PostfixMap)); new FindAllSymbolsActionFactory(&Reporter, &RegexMap));
tooling::ToolInvocation Invocation( tooling::ToolInvocation Invocation(
{std::string("find_all_symbols"), std::string("-fsyntax-only"), {std::string("find_all_symbols"), std::string("-fsyntax-only"),
std::string("-std=c++11"), FileName}, std::string("-std=c++11"), FileName},
Factory->create(), Files.get(), Factory->create(), Files.get(),
std::make_shared<PCHContainerOperations>()); std::make_shared<PCHContainerOperations>());
InMemoryFileSystem->addFile(HeaderName, 0, InMemoryFileSystem->addFile(HeaderName, 0,
llvm::MemoryBuffer::getMemBuffer(Code)); llvm::MemoryBuffer::getMemBuffer(Code));
std::string Content = "#include\"" + std::string(HeaderName) + std::string Content = "#include\"" + std::string(HeaderName) +
"\"\n" "\"\n"
"#include \"internal/internal.h\""; "#include \"" +
InternalHeader + "\"";
#if !defined(_MSC_VER) && !defined(__MINGW32__) #if !defined(_MSC_VER) && !defined(__MINGW32__)
// Test path cleaning for both decls and macros. // Test path cleaning for both decls and macros.
const std::string DirtyHeader = "./internal/./a/b.h"; const std::string DirtyHeader = "./internal/./a/b.h";
Content += "\n#include \"" + DirtyHeader + "\""; Content += "\n#include \"" + DirtyHeader + "\"";
const std::string CleanHeader = "internal/a/b.h"; const std::string CleanHeader = "internal/a/b.h";
const std::string DirtyHeaderContent = const std::string DirtyHeaderContent =
"#define INTERNAL 1\nclass ExtraInternal {};"; "#define INTERNAL 1\nclass ExtraInternal {};";
InMemoryFileSystem->addFile( InMemoryFileSystem->addFile(
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines