Hello community,
here is the log from the commit of package include-what-you-use for
openSUSE:Factory checked in at 2019-03-28 22:49:06
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/include-what-you-use (Old)
and /work/SRC/openSUSE:Factory/.include-what-you-use.new.25356 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "include-what-you-use"
Thu Mar 28 22:49:06 2019 rev:4 rq:689274 version:0.11
Changes:
--------
---
/work/SRC/openSUSE:Factory/include-what-you-use/include-what-you-use.changes
2018-05-10 15:49:52.400222759 +0200
+++
/work/SRC/openSUSE:Factory/.include-what-you-use.new.25356/include-what-you-use.changes
2019-03-28 22:49:07.567049965 +0100
@@ -1,0 +2,20 @@
+Tue Dec 18 22:08:52 UTC 2018 - aaronpuch...@alice-dsl.net
+
+- Update to version 0.11, update LLVM/Clang to version 7.
+ * Improved recognition of template and specialization uses.
+ * Improved CMake build system, see docs for build instructions.
+ * Improved mappings for Boost, Intel intrinsics and libstdc++.
+ * Several bug fixes and improvements.
+ * Add --basedir argument to interpret IWYU output from another
+ source tree.
+ * Handle namespaces better.
+ * Add --only_re switch to filter affected files.
+ * Add --reorder/--noreorder switch to toggle reordering of
+ includes.
+- Drop obsolete llvm-link.patch.
+- Rebase iwyu_include_picker.patch.
+- Update man page, sort options alphabetically.
+- Remove runtime dependency on clang - the builtin headers are now
+ included in libclang.
+
+-------------------------------------------------------------------
Old:
----
include-what-you-use-0.10.src.tar.gz
llvm-link.patch
New:
----
include-what-you-use-0.11.src.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ include-what-you-use.spec ++++++
--- /var/tmp/diff_new_pack.KWPj4i/_old 2019-03-28 22:49:08.103049868 +0100
+++ /var/tmp/diff_new_pack.KWPj4i/_new 2019-03-28 22:49:08.103049868 +0100
@@ -1,7 +1,7 @@
#
# spec file for package include-what-you-use
#
-# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany.
# Copyright (c) 2018 Aaron Puchert.
#
# All modifications and additions to the file contributed by third parties
@@ -13,12 +13,12 @@
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.
-# Please submit bugfixes or comments via http://bugs.opensuse.org/
+# Please submit bugfixes or comments via https://bugs.opensuse.org/
#
Name: include-what-you-use
-Version: 0.10
+Version: 0.11
Release: 0
Summary: A tool to analyze #includes in C and C++ source files
License: NCSA
@@ -26,20 +26,17 @@
Url: https://include-what-you-use.org/
Source0:
https://include-what-you-use.org/downloads/%{name}-%{version}.src.tar.gz
Source1: %{name}.1.gz
-Patch0: llvm-link.patch
Patch1: fix-shebang.patch
Patch2: iwyu_include_picker.patch
Patch3: remove-x86-specific-code.patch
-BuildRequires: clang6
-BuildRequires: clang6-devel
+BuildRequires: clang7
+BuildRequires: clang7-devel
BuildRequires: cmake
%if 0%{?sle_version} && 0%{?sle_version} <= 130000 && !0%{?is_opensuse}
BuildRequires: gcc6
BuildRequires: gcc6-c++
%endif
-BuildRequires: llvm6-devel
-# We need the compiler-specific headers in /usr/lib64/clang/.
-Requires: clang6
+BuildRequires: llvm7-devel
BuildRoot: %{_tmppath}/%{name}-%{version}-build
%description
@@ -67,7 +64,6 @@
%prep
%setup -q -n %{name}
-%patch0 -p1
%patch1 -p1
%patch2 -p1
%patch3 -p1
++++++ fix-shebang.patch ++++++
--- /var/tmp/diff_new_pack.KWPj4i/_old 2019-03-28 22:49:08.123049864 +0100
+++ /var/tmp/diff_new_pack.KWPj4i/_new 2019-03-28 22:49:08.123049864 +0100
@@ -16,5 +16,5 @@
-#!/usr/bin/env python
+#!/usr/bin/python
- """ Driver to consume a Clang compilation database and invoke IWYU.
+ from __future__ import print_function
++++++ include-what-you-use-0.10.src.tar.gz ->
include-what-you-use-0.11.src.tar.gz ++++++
++++ 17843 lines of diff (skipped)
++++++ include-what-you-use.1.gz ++++++
--- /var/tmp/diff_new_pack.KWPj4i/_old 2019-03-28 22:49:08.459049803 +0100
+++ /var/tmp/diff_new_pack.KWPj4i/_new 2019-03-28 22:49:08.459049803 +0100
@@ -61,9 +61,21 @@
.BI --mapping_file= filename
Use the given mapping file.
.TP
+.B --max_line_length
+Maximum line length for includes.
+Note that this only affects the comments and their alignment, the maximum line
+length can still be exceeded with long filenames (default: 80).
+.TP
+.B --no_comments
+Do not add comments after includes about which symbols the header was required
+for.
+.TP
.B --no_default_mappings
Do not use the default mappings.
.TP
+.B --no_fwd_decls
+Do not use forward declarations, and instead always include the required
header.
+.TP
.B --pch_in_code
Mark the first include in a translation unit as a precompiled header. Use
.B --pch_in_code
@@ -93,23 +105,14 @@
No new includes are added, existing ones are removed.
.RE
.TP
+.B --quoted_includes_first
+When sorting includes, place quoted ones first.
+.TP
.B --transitive_includes_only
Do not suggest that a file should add
.IR foo.h " unless " foo.h
is already visible in the file's transitive includes.
.TP
-.B --max_line_length
-Maximum line length for includes.
-Note that this only affects the comments and their alignment, the maximum line
-length can still be exceeded with long filenames (default: 80).
-.TP
-.B --no_comments
-Do not add comments after includes about which symbols the header was required
-for.
-.TP
-.B --no_fwd_decls
-Do not use forward declarations, and instead always include the required
header.
-.TP
.BI --verbose= level
Set verbosity. At the highest level, this will dump the AST of the source file
and explain all decisions.
++++++ iwyu_include_picker.patch ++++++
--- /var/tmp/diff_new_pack.KWPj4i/_old 2019-03-28 22:49:08.495049797 +0100
+++ /var/tmp/diff_new_pack.KWPj4i/_new 2019-03-28 22:49:08.495049797 +0100
@@ -1,17 +1,46 @@
diff --git a/iwyu_include_picker.cc b/iwyu_include_picker.cc
-index 840057f..0f5cb37 100644
+index be318e2..089e911 100644
--- a/iwyu_include_picker.cc
+++ b/iwyu_include_picker.cc
-@@ -75,7 +75,7 @@ struct IncludeMapEntry { // A POD so we can make the
input static
+@@ -75,14 +75,14 @@ struct IncludeMapEntry { // A POD so we can make the
input static
namespace {
// Listed below are all IWYU's native symbol and include mappings,
-// loosely based on GCC 4.4's libc and libstdc++.
-+// loosely based on GCC 7's libc and libstdc++.
++// loosely based on GCC 8's libc and libstdc++.
// Symbol -> include mappings for GNU libc
const IncludeMapEntry libc_symbol_map[] = {
-@@ -240,7 +240,7 @@ const IncludeMapEntry libstdcpp_symbol_map[] = {
+ // For library symbols that can be defined in more than one header
+ // file, maps from symbol-name to legitimate header files.
+ // This list was generated via
+- // grep -R '__.*_defined' /usr/include | perl -nle
'm,/usr/include/([^:]*):#\s*\S+ __(.*)_defined, and print qq@ { "$2",
kPublic, "<$1>", kPublic },@' | sort -u
++ // grep -R '__.*_defined' /usr/include | perl -nle
'm,/usr/include/([^:]*):#\s*\S+ __(.*)_defined, and print qq@ { "$2", kPublic,
"<$1>", kPublic },@' | sort -u
+ // I ignored all entries that only appeared once on the list (eg uint32_t).
+ // I then added in NULL, which according to [diff.null] C.2.2.3, can
+ // be defined in <clocale>, <cstddef>, <cstdio>, <cstdlib>,
+@@ -237,11 +237,28 @@ const IncludeMapEntry libstdcpp_symbol_map[] = {
+ { "std::char_traits", kPrivate, "<string>", kPublic },
+ { "std::char_traits", kPrivate, "<ostream>", kPublic },
+ { "std::char_traits", kPrivate, "<istream>", kPublic },
++ // Using pair.
++ { "std::pair", kPrivate, "<map>", kPublic },
++ { "std::pair", kPrivate, "<multimap>", kPublic },
++ { "std::pair", kPrivate, "<utility>", kPublic },
++ // Streams.
++ { "std::istringstream", kPrivate, "<sstream>", kPublic },
++ { "std::ostringstream", kPrivate, "<sstream>", kPublic },
++ { "std::stringstream", kPrivate, "<sstream>", kPublic },
++ { "std::wistringstream", kPrivate, "<sstream>", kPublic },
++ { "std::wostringstream", kPrivate, "<sstream>", kPublic },
++ { "std::wstringstream", kPrivate, "<sstream>", kPublic },
++ { "std::ifstream", kPrivate, "<fstream>", kPublic },
++ { "std::ofstream", kPrivate, "<fstream>", kPublic },
++ { "std::fstream", kPrivate, "<fstream>", kPublic },
++ { "std::wifstream", kPrivate, "<fstream>", kPublic },
++ { "std::wofstream", kPrivate, "<fstream>", kPublic },
++ { "std::wfstream", kPrivate, "<fstream>", kPublic },
+ };
// Private -> public include mappings for GNU libc
const IncludeMapEntry libc_include_map[] = {
@@ -20,7 +49,7 @@
// When I saw more than one mapping for these, I typically picked
// what I thought was the "best" one.
{ "<bits/a.out.h>", kPrivate, "<a.out.h>", kPublic },
-@@ -248,6 +248,7 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -249,6 +266,7 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/byteswap.h>", kPrivate, "<byteswap.h>", kPublic },
{ "<bits/cmathcalls.h>", kPrivate, "<complex.h>", kPublic },
{ "<bits/confname.h>", kPrivate, "<unistd.h>", kPublic },
@@ -28,7 +57,7 @@
{ "<bits/dirent.h>", kPrivate, "<dirent.h>", kPublic },
{ "<bits/dlfcn.h>", kPrivate, "<dlfcn.h>", kPublic },
{ "<bits/elfclass.h>", kPrivate, "<link.h>", kPublic },
-@@ -261,9 +262,18 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -262,9 +280,18 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/fcntl2.h>", kPrivate, "<fcntl.h>", kPublic },
{ "<bits/fenv.h>", kPrivate, "<fenv.h>", kPublic },
{ "<bits/fenvinline.h>", kPrivate, "<fenv.h>", kPublic },
@@ -47,7 +76,7 @@
{ "<bits/hwcap.h>", kPrivate, "<sys/auxv.h>", kPublic },
{ "<bits/inf.h>", kPrivate, "<math.h>", kPublic },
{ "<bits/inotify.h>", kPrivate, "<sys/inotify.h>", kPublic },
-@@ -271,6 +281,7 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -272,6 +299,7 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/ioctls.h>", kPrivate, "<sys/ioctl.h>", kPublic },
{ "<bits/ipc.h>", kPrivate, "<sys/ipc.h>", kPublic },
{ "<bits/ipctypes.h>", kPrivate, "<sys/ipc.h>", kPublic },
@@ -55,7 +84,7 @@
{ "<bits/libio-ldbl.h>", kPrivate, "<libio.h>", kPublic },
{ "<bits/link.h>", kPrivate, "<link.h>", kPublic },
{ "<bits/locale.h>", kPrivate, "<locale.h>", kPublic },
-@@ -304,7 +315,9 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -305,7 +333,9 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/shm.h>", kPrivate, "<sys/shm.h>", kPublic },
{ "<bits/sigaction.h>", kPrivate, "<signal.h>", kPublic },
{ "<bits/sigcontext.h>", kPrivate, "<signal.h>", kPublic },
@@ -65,7 +94,7 @@
{ "<bits/signum.h>", kPrivate, "<signal.h>", kPublic },
{ "<bits/sigset.h>", kPrivate, "<signal.h>", kPublic },
{ "<bits/sigstack.h>", kPrivate, "<signal.h>", kPublic },
-@@ -313,10 +326,13 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -314,10 +344,13 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/socket.h>", kPrivate, "<sys/socket.h>", kPublic },
{ "<bits/socket2.h>", kPrivate, "<sys/socket.h>", kPublic },
{ "<bits/socket_type.h>", kPrivate, "<sys/socket.h>", kPublic },
@@ -79,7 +108,7 @@
{ "<bits/stdio-ldbl.h>", kPrivate, "<stdio.h>", kPublic },
{ "<bits/stdio-lock.h>", kPrivate, "<libio.h>", kPublic },
{ "<bits/stdio.h>", kPrivate, "<stdio.h>", kPublic },
-@@ -329,6 +345,8 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -330,6 +363,8 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/string.h>", kPrivate, "<string.h>", kPublic },
{ "<bits/string2.h>", kPrivate, "<string.h>", kPublic },
{ "<bits/string3.h>", kPrivate, "<string.h>", kPublic },
@@ -88,7 +117,7 @@
{ "<bits/stropts.h>", kPrivate, "<stropts.h>", kPublic },
{ "<bits/sys_errlist.h>", kPrivate, "<stdio.h>", kPublic },
{ "<bits/syscall.h>", kPrivate, "<sys/syscall.h>", kPrivate },
-@@ -341,7 +359,11 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -342,7 +377,11 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/timerfd.h>", kPrivate, "<sys/timerfd.h>", kPublic },
{ "<bits/timex.h>", kPrivate, "<sys/timex.h>", kPublic },
{ "<bits/types.h>", kPrivate, "<sys/types.h>", kPublic },
@@ -100,7 +129,7 @@
{ "<bits/unistd.h>", kPrivate, "<unistd.h>", kPublic },
{ "<bits/ustat.h>", kPrivate, "<sys/ustat.h>", kPrivate },
{ "<bits/utmp.h>", kPrivate, "<utmp.h>", kPublic },
-@@ -352,6 +374,8 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -353,6 +392,8 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/wchar-ldbl.h>", kPrivate, "<wchar.h>", kPublic },
{ "<bits/wchar.h>", kPrivate, "<wchar.h>", kPublic },
{ "<bits/wchar2.h>", kPrivate, "<wchar.h>", kPublic },
@@ -109,7 +138,7 @@
{ "<bits/wordsize.h>", kPrivate, "<limits.h>", kPublic },
{ "<bits/xopen_lim.h>", kPrivate, "<limits.h>", kPublic },
{ "<bits/xtitypes.h>", kPrivate, "<stropts.h>", kPublic },
-@@ -359,24 +383,33 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -360,24 +401,33 @@ const IncludeMapEntry libc_include_map[] = {
// # error "Never use <bits/dlfcn.h> directly; include <dlfcn.h> instead."
// or
// # error "Never include <bits/socket_type.h> directly; use <sys/socket.h>
instead."
@@ -144,7 +173,7 @@
{ "<bits/in.h>", kPrivate, "<netinet/in.h>", kPublic },
{ "<bits/inf.h>", kPrivate, "<math.h>", kPublic },
{ "<bits/inotify.h>", kPrivate, "<sys/inotify.h>", kPublic },
-@@ -384,30 +417,78 @@ const IncludeMapEntry libc_include_map[] = {
+@@ -385,30 +435,78 @@ const IncludeMapEntry libc_include_map[] = {
{ "<bits/ioctls.h>", kPrivate, "<sys/ioctl.h>", kPublic },
{ "<bits/ipc.h>", kPrivate, "<sys/ipc.h>", kPublic },
{ "<bits/ipctypes.h>", kPrivate, "<sys/ipc.h>", kPublic },
@@ -228,253 +257,24 @@
// Top-level #includes that just forward to another file:
// $ for i in /usr/include/*; do [ -f $i ] && [ `wc -l < $i` = 1 ] && echo
$i; done
// (poll.h, syscall.h, syslog.h, ustat.h, wait.h).
-@@ -548,45 +629,86 @@ const char* stdlib_cpp_public_headers[] = {
-
- // Private -> public include mappings for GNU libstdc++
- const IncludeMapEntry libstdcpp_include_map[] = {
-- // ( cd
/usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1
&& grep '^ *# *include' {ext/,tr1/,}* | perl -nle 'm/^([^:]+).*<([^>]+)>/ &&
print qq@ { "<$2>", kPrivate, "<$1>", kPublic },@' | grep -e bits/ -e
tr1_impl/ | sort -u)
-+ // ( cd /usr/include/c++/7 && grep '^ *# *include' {ext/,tr1/,}* | perl
-nle 'm/^([^:]+).*<([^>]+)>/ && print qq@ { "<$2>", kPrivate, "<$1>", kPublic
},@' | grep -e bits/ -e tr1_impl/ | sort -u)
- // I removed a lot of 'meaningless' dependencies -- for instance,
- // <functional> #includes <bits/stringfwd.h>, but if someone is
- // using strings, <functional> isn't enough to satisfy iwyu.
- // We may need to add other dirs in future versions of gcc.
-- { "<bits/algorithmfwd.h>", kPrivate, "<algorithm>", kPublic },
-+ { "<bits/allocated_ptr.h>", kPrivate, "<future>", kPublic },
- { "<bits/allocator.h>", kPrivate, "<memory>", kPublic },
-+ { "<bits/alloc_traits.h>", kPrivate, "<scoped_allocator>", kPublic },
-+ { "<bits/atomic_base.h>", kPrivate, "<atomic>", kPublic },
-+ { "<bits/atomic_futex.h>", kPrivate, "<future>", kPublic },
- { "<bits/atomic_word.h>", kPrivate, "<ext/atomicity.h>", kPublic },
- { "<bits/basic_file.h>", kPrivate, "<fstream>", kPublic },
- { "<bits/basic_ios.h>", kPrivate, "<ios>", kPublic },
- { "<bits/basic_string.h>", kPrivate, "<string>", kPublic },
- { "<bits/basic_string.tcc>", kPrivate, "<string>", kPublic },
-- { "<bits/boost_sp_shared_count.h>", kPrivate, "<memory>", kPublic },
-- { "<bits/c++io.h>", kPrivate, "<ext/stdio_sync_filebuf.h>", kPublic },
- { "<bits/c++config.h>", kPrivate, "<cstddef>", kPublic },
- { "<bits/char_traits.h>", kPrivate, "<string>", kPublic },
-- { "<bits/cmath.tcc>", kPrivate, "<cmath>", kPublic },
-+ { "<bits/c++io.h>", kPrivate, "<ext/stdio_sync_filebuf.h>", kPublic },
- { "<bits/codecvt.h>", kPrivate, "<fstream>", kPublic },
-+ { "<bits/cpp_type_traits.h>", kPrivate, "<type_traits>", kPublic },
-+ { "<bits/cxxabi_forced.h>", kPrivate, "<cxxabi.h>", kPublic },
-+ { "<bits/cxxabi_init_exception.h>", kPrivate, "<cxxabi.h>", kPublic },
- { "<bits/cxxabi_tweaks.h>", kPrivate, "<cxxabi.h>", kPublic },
- { "<bits/deque.tcc>", kPrivate, "<deque>", kPublic },
-+ { "<bits/enable_special_members.h>", kPrivate, "<optional>", kPublic },
-+ { "<bits/error_constants.h>", kPrivate, "<system_error>", kPublic },
-+ { "<bits/exception.h>", kPrivate, "<exception>", kPublic },
-+ { "<bits/exception_ptr.h>", kPrivate, "<exception>", kPublic },
-+ { "<bits/forward_list.h>", kPrivate, "<forward_list>", kPublic },
-+ { "<bits/forward_list.tcc>", kPrivate, "<forward_list>", kPublic },
- { "<bits/fstream.tcc>", kPrivate, "<fstream>", kPublic },
-+ { "<bits/functexcept.h>", kPrivate, "<optional>", kPublic },
-+ { "<bits/functexcept.h>", kPrivate, "<variant>", kPublic },
- { "<bits/functional_hash.h>", kPrivate, "<unordered_map>", kPublic },
- { "<bits/gslice.h>", kPrivate, "<valarray>", kPublic },
- { "<bits/gslice_array.h>", kPrivate, "<valarray>", kPublic },
-+ { "<bits/gthr.h>", kPrivate, "<thread>", kPublic },
-+ { "<bits/hash_bytes.h>", kPrivate, "<typeinfo>", kPublic },
- { "<bits/hashtable.h>", kPrivate, "<unordered_map>", kPublic },
- { "<bits/hashtable.h>", kPrivate, "<unordered_set>", kPublic },
- { "<bits/indirect_array.h>", kPrivate, "<valarray>", kPublic },
-+ { "<bits/invoke.h>", kPrivate, "<functional>", kPublic },
- { "<bits/ios_base.h>", kPrivate, "<iostream>", kPublic },
- { "<bits/ios_base.h>", kPrivate, "<ios>", kPublic },
- { "<bits/ios_base.h>", kPrivate, "<iomanip>", kPublic },
-+ { "<bits/istream.tcc>", kPrivate, "<istream>", kPublic },
-+ { "<bits/list.tcc>", kPrivate, "<list>", kPublic },
- { "<bits/locale_classes.h>", kPrivate, "<locale>", kPublic },
-+ { "<bits/locale_conv.h>", kPrivate, "<locale>", kPublic },
- { "<bits/locale_facets.h>", kPrivate, "<locale>", kPublic },
- { "<bits/locale_facets_nonio.h>", kPrivate, "<locale>", kPublic },
- { "<bits/localefwd.h>", kPrivate, "<locale>", kPublic },
- { "<bits/mask_array.h>", kPrivate, "<valarray>", kPublic },
-- { "<bits/ostream.tcc>", kPrivate, "<ostream>", kPublic },
-+ { "<bits/move.h>", kPrivate, "<utility>", kPublic },
-+ { "<bits/nested_exception.h>", kPrivate, "<exception>", kPublic },
-+ { "<bits/opt_random.h>", kPrivate, "<random>", kPublic },
- { "<bits/ostream_insert.h>", kPrivate, "<ostream>", kPublic },
-+ { "<bits/ostream.tcc>", kPrivate, "<ostream>", kPublic },
-+ { "<bits/parse_numbers.h>", kPrivate, "<chrono>", kPublic },
- { "<bits/postypes.h>", kPrivate, "<iostream>", kPublic },
-+ { "<bits/ptr_traits.h>", kPrivate, "<ext/pointer.h>", kPublic },
-+ { "<bits/quoted_string.h>", kPrivate, "<iomanip>", kPublic },
-+ { "<bits/random.h>", kPrivate, "<random>", kPublic },
-+ { "<bits/random.tcc>", kPrivate, "<random>", kPublic },
-+ { "<bits/range_access.h>", kPrivate, "<iterator>", kPublic },
-+ { "<bits/regex_automaton.h>", kPrivate, "<regex>", kPublic },
-+ { "<bits/regex_compiler.h>", kPrivate, "<regex>", kPublic },
-+ { "<bits/regex_constants.h>", kPrivate, "<regex>", kPublic },
-+ { "<bits/regex_error.h>", kPrivate, "<regex>", kPublic },
-+ { "<bits/regex_executor.h>", kPrivate, "<regex>", kPublic },
-+ { "<bits/regex.h>", kPrivate, "<regex>", kPublic },
-+ { "<bits/regex_scanner.h>", kPrivate, "<regex>", kPublic },
-+ { "<bits/shared_ptr_atomic.h>", kPrivate, "<memory>", kPublic },
-+ { "<bits/shared_ptr.h>", kPrivate, "<memory>", kPublic },
- { "<bits/slice_array.h>", kPrivate, "<valarray>", kPublic },
-+ { "<bits/specfun.h>", kPrivate, "<cmath>", kPublic },
-+ { "<bits/sstream.tcc>", kPrivate, "<sstream>", kPublic },
-+ { "<bits/std_abs.h>", kPrivate, "<cmath>", kPublic },
-+ { "<bits/std_function.h>", kPrivate, "<functional>", kPublic },
-+ { "<bits/std_mutex.h>", kPrivate, "<mutex>", kPublic },
- { "<bits/stl_algo.h>", kPrivate, "<algorithm>", kPublic },
- { "<bits/stl_algobase.h>", kPrivate, "<algorithm>", kPublic },
- { "<bits/stl_bvector.h>", kPrivate, "<vector>", kPublic },
-@@ -603,7 +725,6 @@ const IncludeMapEntry libstdcpp_include_map[] = {
- { "<bits/stl_multiset.h>", kPrivate, "<set>", kPublic },
- { "<bits/stl_numeric.h>", kPrivate, "<numeric>", kPublic },
- { "<bits/stl_pair.h>", kPrivate, "<utility>", kPublic },
-- { "<bits/stl_pair.h>", kPrivate, "<tr1/utility>", kPublic },
- { "<bits/stl_queue.h>", kPrivate, "<queue>", kPublic },
- { "<bits/stl_raw_storage_iter.h>", kPrivate, "<memory>", kPublic },
- { "<bits/stl_relops.h>", kPrivate, "<utility>", kPublic },
-@@ -618,99 +739,85 @@ const IncludeMapEntry libstdcpp_include_map[] = {
- { "<bits/streambuf.tcc>", kPrivate, "<streambuf>", kPublic },
- { "<bits/streambuf_iterator.h>", kPrivate, "<iterator>", kPublic },
- { "<bits/stringfwd.h>", kPrivate, "<string>", kPublic },
-+ { "<bits/string_view.tcc>", kPrivate, "<string_view>", kPublic },
-+ { "<bits/unique_ptr.h>", kPrivate, "<memory>", kPublic },
-+ { "<bits/unordered_map.h>", kPrivate, "<unordered_map>", kPublic },
-+ { "<bits/unordered_set.h>", kPrivate, "<unordered_set>", kPublic },
-+ { "<bits/uses_allocator.h>", kPrivate, "<memory>", kPublic },
- { "<bits/valarray_after.h>", kPrivate, "<valarray>", kPublic },
- { "<bits/valarray_array.h>", kPrivate, "<valarray>", kPublic },
- { "<bits/valarray_before.h>", kPrivate, "<valarray>", kPublic },
- { "<bits/vector.tcc>", kPrivate, "<vector>", kPublic },
-- { "<tr1_impl/array>", kPrivate, "<array>", kPublic },
-- { "<tr1_impl/array>", kPrivate, "<tr1/array>", kPublic },
-- { "<tr1_impl/boost_shared_ptr.h>", kPrivate, "<memory>", kPublic },
-- { "<tr1_impl/boost_shared_ptr.h>", kPrivate, "<tr1/memory>", kPublic },
-- { "<tr1_impl/boost_sp_counted_base.h>", kPrivate, "<memory>", kPublic },
-- { "<tr1_impl/boost_sp_counted_base.h>", kPrivate, "<tr1/memory>", kPublic },
-- { "<tr1_impl/cctype>", kPrivate, "<cctype>", kPublic },
-- { "<tr1_impl/cctype>", kPrivate, "<tr1/cctype>", kPublic },
-- { "<tr1_impl/cfenv>", kPrivate, "<cfenv>", kPublic },
-- { "<tr1_impl/cfenv>", kPrivate, "<tr1/cfenv>", kPublic },
-- { "<tr1_impl/cinttypes>", kPrivate, "<cinttypes>", kPublic },
-- { "<tr1_impl/cinttypes>", kPrivate, "<tr1/cinttypes>", kPublic },
-- { "<tr1_impl/cmath>", kPrivate, "<cmath>", kPublic },
-- { "<tr1_impl/cmath>", kPrivate, "<tr1/cmath>", kPublic },
-- { "<tr1_impl/complex>", kPrivate, "<complex>", kPublic },
-- { "<tr1_impl/complex>", kPrivate, "<tr1/complex>", kPublic },
-- { "<tr1_impl/cstdint>", kPrivate, "<cstdint>", kPublic },
-- { "<tr1_impl/cstdint>", kPrivate, "<tr1/cstdint>", kPublic },
-- { "<tr1_impl/cstdio>", kPrivate, "<cstdio>", kPublic },
-- { "<tr1_impl/cstdio>", kPrivate, "<tr1/cstdio>", kPublic },
-- { "<tr1_impl/cstdlib>", kPrivate, "<cstdlib>", kPublic },
-- { "<tr1_impl/cstdlib>", kPrivate, "<tr1/cstdlib>", kPublic },
-- { "<tr1_impl/cwchar>", kPrivate, "<cwchar>", kPublic },
-- { "<tr1_impl/cwchar>", kPrivate, "<tr1/cwchar>", kPublic },
-- { "<tr1_impl/cwctype>", kPrivate, "<cwctype>", kPublic },
-- { "<tr1_impl/cwctype>", kPrivate, "<tr1/cwctype>", kPublic },
-- { "<tr1_impl/functional>", kPrivate, "<functional>", kPublic },
-- { "<tr1_impl/functional>", kPrivate, "<tr1/functional>", kPublic },
-- { "<tr1_impl/random>", kPrivate, "<random>", kPublic },
-- { "<tr1_impl/random>", kPrivate, "<tr1/random>", kPublic },
-- { "<tr1_impl/regex>", kPrivate, "<regex>", kPublic },
-- { "<tr1_impl/regex>", kPrivate, "<tr1/regex>", kPublic },
-- { "<tr1_impl/type_traits>", kPrivate, "<tr1/type_traits>", kPublic },
-- { "<tr1_impl/type_traits>", kPrivate, "<type_traits>", kPublic },
-- { "<tr1_impl/unordered_map>", kPrivate, "<tr1/unordered_map>", kPublic },
-- { "<tr1_impl/unordered_map>", kPrivate, "<unordered_map>", kPublic },
-- { "<tr1_impl/unordered_set>", kPrivate, "<tr1/unordered_set>", kPublic },
-- { "<tr1_impl/unordered_set>", kPrivate, "<unordered_set>", kPublic },
-- { "<tr1_impl/utility>", kPrivate, "<tr1/utility>", kPublic },
-- { "<tr1_impl/utility>", kPrivate, "<utility>", kPublic },
-- { "<bits/move.h>", kPrivate, "<utility>", kPublic },
-- // Hash and hashtable-based containers.
-- { "<tr1_impl/functional_hash.h>", kPrivate, "<tr1/functional>", kPublic },
-- { "<tr1_impl/functional_hash.h>", kPrivate, "<tr1/unordered_map>", kPublic
},
-- { "<tr1_impl/functional_hash.h>", kPrivate, "<tr1/unordered_set>", kPublic
},
-- { "<tr1/functional_hash.h>", kPrivate, "<tr1/functional>", kPublic },
-- { "<tr1/functional_hash.h>", kPrivate, "<tr1/unordered_map>", kPublic },
-- { "<tr1/functional_hash.h>", kPrivate, "<tr1/unordered_set>", kPublic },
-- { "<tr1_impl/hashtable>", kPrivate, "<tr1/unordered_map>", kPublic },
-- { "<tr1_impl/hashtable>", kPrivate, "<tr1/unordered_set>", kPublic },
-- { "<tr1/hashtable.h>", kPrivate, "<tr1/unordered_map>", kPublic },
-- { "<tr1/hashtable.h>", kPrivate, "<tr1/unordered_set>", kPublic },
+@@ -794,14 +892,14 @@ const IncludeMapEntry libstdcpp_include_map[] = {
+ { "<tr1/hashtable.h>", kPrivate, "<tr1/unordered_map>", kPublic },
+ { "<tr1/hashtable.h>", kPrivate, "<tr1/unordered_set>", kPublic },
// All .tcc files are gcc internal-include files. We get them from
- // ( cd
/usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1
&& grep -R '^ *# *include.*tcc' * | perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/
&& print qq@ { "<$2>", kPrivate, "<$1>", kPublic },@' | sort )
-+ // ( cd /usr/include/c++/7 && grep -R '^ *# *include.*tcc' * | perl -nle
'm/^([^:]+).*[<"]([^>"]+)[>"]/ && print qq@ { "<$2>", kPrivate, "<$1>",
kPublic },@' | sort )
++ // ( cd /usr/include/c++/8 && grep -R '^ *# *include.*tcc' * | perl -nle
'm/^([^:]+).*[<"]([^>"]+)[>"]/ && print qq@ { "<$2>", kPrivate, "<$1>",
kPublic },@' | sort )
// I had to manually edit some of the entries to say the map-to is private.
- { "<bits/basic_ios.tcc>", kPrivate, "<bits/basic_ios.h>", kPrivate },
- { "<bits/basic_string.tcc>", kPrivate, "<string>", kPublic },
-- { "<bits/cmath.tcc>", kPrivate, "<cmath>", kPublic },
- { "<bits/deque.tcc>", kPrivate, "<deque>", kPublic },
-+ { "<bits/forward_list.tcc>", kPrivate, "<forward_list>", kPublic },
- { "<bits/fstream.tcc>", kPrivate, "<fstream>", kPublic },
- { "<bits/istream.tcc>", kPrivate, "<istream>", kPublic },
- { "<bits/list.tcc>", kPrivate, "<list>", kPublic },
-- { "<bits/locale_classes.tcc>", kPrivate,
-+ { "<bits/locale_classes.tcc>", kPrivate,
- "<bits/locale_classes.h>", kPrivate },
- { "<bits/locale_facets.tcc>", kPrivate, "<bits/locale_facets.h>", kPrivate
},
- { "<bits/locale_facets_nonio.tcc>", kPrivate,
- "<bits/locale_facets_nonio.h>", kPrivate },
- { "<bits/ostream.tcc>", kPrivate, "<ostream>", kPublic },
-+ { "<bits/random.tcc>", kPrivate, "<random>", kPublic },
-+ { "<bits/regex_automaton.tcc>", kPrivate,
-+ "<bits/regex_automaton.h>", kPrivate },
-+ { "<bits/regex_compiler.tcc>", kPrivate,
-+ "<bits/regex_compiler.h>", kPrivate },
-+ { "<bits/regex_executor.tcc>", kPrivate,
-+ "<bits/regex_executor.h>", kPrivate },
-+ { "<bits/regex_scanner.tcc>", kPrivate, "<bits/regex_scanner.h>", kPrivate
},
-+ { "<bits/regex.tcc>", kPrivate, "<bits/regex.h>", kPrivate },
- { "<bits/sstream.tcc>", kPrivate, "<sstream>", kPublic },
- { "<bits/streambuf.tcc>", kPrivate, "<streambuf>", kPublic },
-- { "<bits/valarray_array.tcc>", kPrivate,
-+ { "<bits/string_view.tcc>", kPrivate, "<string_view>", kPublic },
-+ { "<bits/valarray_array.tcc>", kPrivate,
- "<bits/valarray_array.h>", kPrivate },
- { "<bits/vector.tcc>", kPrivate, "<vector>", kPublic },
-- { "<debug/safe_iterator.tcc>", kPrivate, "<debug/safe_iterator.h>", kPublic
},
-+ { "<debug/safe_iterator.tcc>", kPrivate,
-+ "<debug/safe_iterator.h>", kPublic },
-+ { "<debug/safe_local_iterator.tcc>", kPrivate,
-+ "<debug/safe_local_iterator.h>", kPublic },
-+ { "<debug/safe_sequence.tcc>", kPrivate, "<debug/safe_sequence.h>", kPublic
},
-+ { "<debug/safe_unordered_container.tcc>", kPrivate,
-+ "<debug/safe_unordered_container.h>", kPublic },
-+ { "<experimental/bits/string_view.tcc>", kPrivate,
-+ "<experimental/string_view>", kPublic },
-+ { "<random.tcc>", kPrivate, "<ext/random>", kPublic },
-+ { "<tr1/bessel_function.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/bessel_function.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/beta_function.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/beta_function.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/ell_integral.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/ell_integral.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/exp_integral.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/exp_integral.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/gamma.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/gamma.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/hypergeometric.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/hypergeometric.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/legendre_function.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/legendre_function.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/modified_bessel_func.tcc>", kPrivate, "<bits/specfun.h>", kPrivate
},
- { "<tr1/modified_bessel_func.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/poly_hermite.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/poly_hermite.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/poly_laguerre.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/poly_laguerre.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-+ { "<tr1/random.tcc>", kPrivate, "<tr1/random>", kPublic },
-+ { "<tr1/riemann_zeta.tcc>", kPrivate, "<bits/specfun.h>", kPrivate },
- { "<tr1/riemann_zeta.tcc>", kPrivate, "<tr1/cmath>", kPublic },
-- { "<tr1_impl/random.tcc>", kPrivate, "<tr1_impl/random>", kPrivate },
-+ { "<tr2/bool_set.tcc>", kPrivate, "<tr2/bool_set>", kPublic },
-+ { "<tr2/dynamic_bitset.tcc>", kPrivate, "<tr2/dynamic_bitset>", kPublic },
-+ { "<vstring.tcc>", kPrivate, "<ext/vstring.h>", kPublic },
+ { "<bits/cmath.tcc>", kPrivate, "<cmath>", kPublic },
+ { "<debug/safe_iterator.tcc>", kPrivate, "<debug/safe_iterator.h>", kPublic
},
+ { "<tr1_impl/random.tcc>", kPrivate, "<tr1_impl/random>", kPrivate },
// Some bits->bits #includes: A few files in bits re-export
// symbols from other files in bits.
- // ( cd
/usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1
&& grep '^ *# *include.*bits/' bits/* | perl -nle 'm/^([^:]+).*<([^>]+)>/ &&
print qq@ { "<$2>", kPrivate, "<$1>", kPrivate },@' | grep bits/ | sort -u)
-+ // ( cd /usr/include/c++/7 && grep '^ *# *include.*bits/' bits/* | perl
-nle 'm/^([^:]+).*<([^>]+)>/ && print qq@ { "<$2>", kPrivate, "<$1>", kPrivate
},@' | grep bits/ | sort -u)
++ // ( cd /usr/include/c++/8 && grep '^ *# *include.*bits/' bits/* | perl
-nle 'm/^([^:]+).*<([^>]+)>/ && print qq@ { "<$2>", kPrivate, "<$1>", kPrivate
},@' | grep bits/ | sort -u)
// and carefully picked reasonable-looking results (algorithm
// *uses* pair but doesn't *re-export* pair, for instance).
- { "<bits/boost_concept_check.h>", kPrivate,
-@@ -749,14 +856,19 @@ const IncludeMapEntry libstdcpp_include_map[] = {
+ { "<bits/c++allocator.h>", kPrivate, "<bits/allocator.h>", kPrivate },
+@@ -826,14 +924,19 @@ const IncludeMapEntry libstdcpp_include_map[] = {
{ "<hash_fun.h>", kPrivate, "<hash_set>", kPublic },
{ "<hashtable.h>", kPrivate, "<hash_map>", kPublic },
{ "<hashtable.h>", kPrivate, "<hash_set>", kPublic },
@@ -492,7 +292,7 @@
// are pretty forgiving: if a user specifies any public header, we
// generally don't require the others.
- // ( cd
/usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1
&& egrep '^ *# *include
<(istream|ostream|iostream|fstream|sstream|streambuf|ios|iosfwd)>' *stream* ios
| perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/ and print qq@ { "<$2>", kPublic,
"<$1>", kPublic },@' | sort -u )
-+ // ( cd /usr/include/c++/7 && egrep '^ *# *include
<(istream|ostream|iostream|fstream|sstream|streambuf|ios|iosfwd)>' *stream* ios
| perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/ and print qq@ { "<$2>", kPublic,
"<$1>", kPublic },@' | sort -u )
++ // ( cd /usr/include/c++/8 && egrep '^ *# *include
<(istream|ostream|iostream|fstream|sstream|streambuf|ios|iosfwd)>' *stream* ios
| perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/ and print qq@ { "<$2>", kPublic,
"<$1>", kPublic },@' | sort -u )
{ "<ios>", kPublic, "<istream>", kPublic },
{ "<ios>", kPublic, "<ostream>", kPublic },
{ "<iosfwd>", kPublic, "<ios>", kPublic },
