This is an archive of the discontinued LLVM Phabricator instance.

Differential D138384

[libc++] Remove libc++'s own <limits.h>
AbandonedPublic

Authored by ldionne on Nov 20 2022, 10:57 AM.

Details

Reviewers
None
Group Reviewers
Restricted Project
Commits
rGf90125434159: [libc++] Remove libc++'s own <limits.h> (#65472)
Summary

We do not define anything beyond the C Library's limits.h, so it
shouldn't be needed. This removes the need for a GCC-specific
workaround, see [1].

[1]: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107795

Diff Detail

Event Timeline

ldionne created this revision.Nov 20 2022, 10:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptNov 20 2022, 10:57 AM
ldionne requested review of this revision.Nov 20 2022, 10:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptNov 20 2022, 10:57 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B198690: Diff 476764.Nov 20 2022, 11:15 AM
ldionne added a comment.Nov 21 2022, 8:02 AM

Blocked on https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107795.

ldionne updated this revision to Diff 480089.Dec 5 2022, 6:24 AM
ldionne retitled this revision from [libc++] Remove workaround for limits.h on GCC to [libc++] Remove libc++'s own <limits.h>.
ldionne edited the summary of this revision. (Show Details)

Remove limits.h instead.

Harbormaster completed remote builds in B201103: Diff 480089.Dec 5 2022, 6:29 AM
ldionne updated this revision to Diff 480096.Dec 5 2022, 7:00 AM

Remove stray limits.h from CMake header list

Harbormaster completed remote builds in B201110: Diff 480096.Dec 5 2022, 8:03 AM
ldionne abandoned this revision.Sep 6 2023, 6:15 AM

[Github PR transition cleanup]

Closing, moved to https://github.com/llvm/llvm-project/pull/65472.

This revision was landed with ongoing or failed builds.Oct 10 2023, 11:06 AM
GitHub <noreply@github.com> added a commit: rGf90125434159: [libc++] Remove libc++'s own <limits.h> (#65472).

Revision Contents

Diff 480089

libcxx/include/limits.h

  • This file was deleted.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_LIMITS_H
#define _LIBCPP_LIMITS_H
/*
limits.h synopsis
Macros:
CHAR_BIT
SCHAR_MIN
SCHAR_MAX
UCHAR_MAX
CHAR_MIN
CHAR_MAX
MB_LEN_MAX
SHRT_MIN
SHRT_MAX
USHRT_MAX
INT_MIN
INT_MAX
UINT_MAX
LONG_MIN
LONG_MAX
ULONG_MAX
LLONG_MIN // C99
LLONG_MAX // C99
ULLONG_MAX // C99
*/
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#ifdef _LIBCPP_COMPILER_GCC
// GCC header limits.h recursively includes itself through another header called
// syslimits.h for some reason. This setup breaks down if we directly
// #include_next GCC's limits.h (reasons not entirely clear to me).
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107795 for more details.
// Therefore, we manually re-create the necessary include sequence below:
// Get the system limits.h defines (force recurse into the next level)
#define _GCC_LIMITS_H_
#define _GCC_NEXT_LIMITS_H
#include_next <limits.h>
// Get the ISO C defines
#undef _GCC_LIMITS_H_
#include_next <limits.h>
#else
# if __has_include_next(<limits.h>)
# include_next <limits.h>
# endif
#endif // _LIBCPP_COMPILER_GCC
#endif // _LIBCPP_LIMITS_H

libcxx/include/module.modulemap.in

Show All 30 Lines module depr [extern_c] {
} }
// <float.h> provided by compiler or C library. // <float.h> provided by compiler or C library.
module inttypes_h { module inttypes_h {
header "inttypes.h" header "inttypes.h"
export stdint_h export stdint_h
export * export *
} }
// <iso646.h> provided by compiler. // <iso646.h> provided by compiler.
// <limits.h> provided by compiler or C library.
module locale_h { module locale_h {
@requires_LIBCXX_ENABLE_LOCALIZATION@ @requires_LIBCXX_ENABLE_LOCALIZATION@
header "locale.h" header "locale.h"
export * export *
} }
module math_h { module math_h {
header "math.h" header "math.h"
export * export *
▲ Show 20 Lines • Show All 1,611 Lines • Show Last 20 Lines

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.sh.cpp

Show First 20 Lines • Show All 390 Lines • ▼ Show 20 Lines
#endif #endif
// RUN: %{build} -DTEST_63 // RUN: %{build} -DTEST_63
#if defined(TEST_63) #if defined(TEST_63)
# include <limits> # include <limits>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_65 // RUN: %{build} -DTEST_64
#if defined(TEST_65) #if defined(TEST_64)
# include <list> # include <list>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_66 // RUN: %{build} -DTEST_65
#if defined(TEST_66) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_65) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale> # include <locale>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_68 // RUN: %{build} -DTEST_67
#if defined(TEST_68) #if defined(TEST_67)
# include <map> # include <map>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_69
#if defined(TEST_69)
# include <memory>
using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif
// RUN: %{build} -DTEST_70 // RUN: %{build} -DTEST_70
#if defined(TEST_70) #if defined(TEST_70)
# include <memory> # include <memory_resource>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_71 // RUN: %{build} -DTEST_71
#if defined(TEST_71) #if defined(TEST_71) && !defined(_LIBCPP_HAS_NO_THREADS)
# include <memory_resource> # include <mutex>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_72 // RUN: %{build} -DTEST_72
#if defined(TEST_72) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_72)
# include <mutex> # include <new>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_73 // RUN: %{build} -DTEST_73
#if defined(TEST_73) #if defined(TEST_73)
# include <new> # include <numbers>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_74 // RUN: %{build} -DTEST_74
#if defined(TEST_74) #if defined(TEST_74)
# include <numbers> # include <numeric>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_75 // RUN: %{build} -DTEST_75
#if defined(TEST_75) #if defined(TEST_75)
# include <numeric> # include <optional>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_76 // RUN: %{build} -DTEST_76
#if defined(TEST_76) #if defined(TEST_76) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <optional> # include <ostream>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_77 // RUN: %{build} -DTEST_77
#if defined(TEST_77) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_77)
# include <ostream> # include <queue>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_78 // RUN: %{build} -DTEST_78
#if defined(TEST_78) #if defined(TEST_78)
# include <queue> # include <random>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_79 // RUN: %{build} -DTEST_79
#if defined(TEST_79) #if defined(TEST_79)
# include <random> # include <ranges>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_80 // RUN: %{build} -DTEST_80
#if defined(TEST_80) #if defined(TEST_80)
# include <ranges>
using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif
// RUN: %{build} -DTEST_81
#if defined(TEST_81)
# include <ratio> # include <ratio>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_82 // RUN: %{build} -DTEST_81
#if defined(TEST_82) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_81) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <regex> # include <regex>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_83 // RUN: %{build} -DTEST_82
#if defined(TEST_83) #if defined(TEST_82)
# include <scoped_allocator> # include <scoped_allocator>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_84 // RUN: %{build} -DTEST_83
#if defined(TEST_84) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_83) && !defined(_LIBCPP_HAS_NO_THREADS)
# include <semaphore> # include <semaphore>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_85 // RUN: %{build} -DTEST_84
#if defined(TEST_85) #if defined(TEST_84)
# include <set> # include <set>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_87 // RUN: %{build} -DTEST_86
#if defined(TEST_87) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_86) && !defined(_LIBCPP_HAS_NO_THREADS)
# include <shared_mutex> # include <shared_mutex>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_88 // RUN: %{build} -DTEST_87
#if defined(TEST_88) #if defined(TEST_87)
# include <span> # include <span>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_89 // RUN: %{build} -DTEST_88
#if defined(TEST_89) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_88) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <sstream> # include <sstream>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_90 // RUN: %{build} -DTEST_89
#if defined(TEST_90) #if defined(TEST_89)
# include <stack> # include <stack>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_94 // RUN: %{build} -DTEST_93
#if defined(TEST_94) #if defined(TEST_93)
# include <stdexcept> # include <stdexcept>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_98 // RUN: %{build} -DTEST_97
#if defined(TEST_98) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_97) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <streambuf> # include <streambuf>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_99 // RUN: %{build} -DTEST_98
#if defined(TEST_99) #if defined(TEST_98)
# include <string> # include <string>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_101 // RUN: %{build} -DTEST_100
#if defined(TEST_101) #if defined(TEST_100)
# include <string_view> # include <string_view>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_102 // RUN: %{build} -DTEST_101
#if defined(TEST_102) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_101) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <strstream> # include <strstream>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_103 // RUN: %{build} -DTEST_102
#if defined(TEST_103) #if defined(TEST_102)
# include <system_error> # include <system_error>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_105 // RUN: %{build} -DTEST_104
#if defined(TEST_105) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_104) && !defined(_LIBCPP_HAS_NO_THREADS)
# include <thread> # include <thread>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_105
#if defined(TEST_105)
# include <tuple>
using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif
// RUN: %{build} -DTEST_106 // RUN: %{build} -DTEST_106
#if defined(TEST_106) #if defined(TEST_106)
# include <tuple> # include <type_traits>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_107 // RUN: %{build} -DTEST_107
#if defined(TEST_107) #if defined(TEST_107)
# include <type_traits> # include <typeindex>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_108 // RUN: %{build} -DTEST_108
#if defined(TEST_108) #if defined(TEST_108)
# include <typeindex> # include <typeinfo>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_109 // RUN: %{build} -DTEST_110
#if defined(TEST_109) #if defined(TEST_110)
# include <typeinfo> # include <unordered_map>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_111 // RUN: %{build} -DTEST_111
#if defined(TEST_111) #if defined(TEST_111)
# include <unordered_map> # include <unordered_set>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_112 // RUN: %{build} -DTEST_112
#if defined(TEST_112) #if defined(TEST_112)
# include <unordered_set> # include <utility>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_113 // RUN: %{build} -DTEST_113
#if defined(TEST_113) #if defined(TEST_113)
# include <utility> # include <valarray>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_114 // RUN: %{build} -DTEST_114
#if defined(TEST_114) #if defined(TEST_114)
# include <valarray> # include <variant>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_115 // RUN: %{build} -DTEST_115
#if defined(TEST_115) #if defined(TEST_115)
# include <variant> # include <vector>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_116 // RUN: %{build} -DTEST_116
#if defined(TEST_116) #if defined(TEST_116)
# include <vector> # include <version>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_117 // RUN: %{build} -DTEST_119
#if defined(TEST_117) #if defined(TEST_119) && __cplusplus >= 201103L
# include <version> # include <experimental/algorithm>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_120 // RUN: %{build} -DTEST_120
#if defined(TEST_120) && __cplusplus >= 201103L #if defined(TEST_120) && __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
# include <experimental/algorithm> # include <experimental/coroutine>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_121 // RUN: %{build} -DTEST_121
#if defined(TEST_121) && __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES) #if defined(TEST_121) && __cplusplus >= 201103L
# include <experimental/coroutine> # include <experimental/deque>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_122 // RUN: %{build} -DTEST_122
#if defined(TEST_122) && __cplusplus >= 201103L #if defined(TEST_122) && __cplusplus >= 201103L
# include <experimental/deque> # include <experimental/forward_list>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_123 // RUN: %{build} -DTEST_123
#if defined(TEST_123) && __cplusplus >= 201103L #if defined(TEST_123) && __cplusplus >= 201103L
# include <experimental/forward_list> # include <experimental/functional>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_124 // RUN: %{build} -DTEST_124
#if defined(TEST_124) && __cplusplus >= 201103L #if defined(TEST_124) && __cplusplus >= 201103L
# include <experimental/functional> # include <experimental/iterator>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_125 // RUN: %{build} -DTEST_125
#if defined(TEST_125) && __cplusplus >= 201103L #if defined(TEST_125) && __cplusplus >= 201103L
# include <experimental/iterator> # include <experimental/list>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_126 // RUN: %{build} -DTEST_126
#if defined(TEST_126) && __cplusplus >= 201103L #if defined(TEST_126) && __cplusplus >= 201103L
# include <experimental/list> # include <experimental/map>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_127 // RUN: %{build} -DTEST_127
#if defined(TEST_127) && __cplusplus >= 201103L #if defined(TEST_127) && __cplusplus >= 201103L
# include <experimental/map> # include <experimental/memory_resource>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_128 // RUN: %{build} -DTEST_128
#if defined(TEST_128) && __cplusplus >= 201103L #if defined(TEST_128) && __cplusplus >= 201103L
# include <experimental/memory_resource> # include <experimental/propagate_const>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_129 // RUN: %{build} -DTEST_129
#if defined(TEST_129) && __cplusplus >= 201103L #if defined(TEST_129) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
# include <experimental/propagate_const> # include <experimental/regex>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_130 // RUN: %{build} -DTEST_130
#if defined(TEST_130) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L #if defined(TEST_130) && __cplusplus >= 201103L
# include <experimental/regex> # include <experimental/set>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_131 // RUN: %{build} -DTEST_131
#if defined(TEST_131) && __cplusplus >= 201103L #if defined(TEST_131) && __cplusplus >= 201103L
# include <experimental/set> # include <experimental/simd>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_132 // RUN: %{build} -DTEST_132
#if defined(TEST_132) && __cplusplus >= 201103L #if defined(TEST_132) && __cplusplus >= 201103L
# include <experimental/simd> # include <experimental/string>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_133 // RUN: %{build} -DTEST_133
#if defined(TEST_133) && __cplusplus >= 201103L #if defined(TEST_133) && __cplusplus >= 201103L
# include <experimental/string> # include <experimental/type_traits>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_134 // RUN: %{build} -DTEST_134
#if defined(TEST_134) && __cplusplus >= 201103L #if defined(TEST_134) && __cplusplus >= 201103L
# include <experimental/type_traits> # include <experimental/unordered_map>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_135 // RUN: %{build} -DTEST_135
#if defined(TEST_135) && __cplusplus >= 201103L #if defined(TEST_135) && __cplusplus >= 201103L
# include <experimental/unordered_map> # include <experimental/unordered_set>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_136 // RUN: %{build} -DTEST_136
#if defined(TEST_136) && __cplusplus >= 201103L #if defined(TEST_136) && __cplusplus >= 201103L
# include <experimental/unordered_set> # include <experimental/utility>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_137 // RUN: %{build} -DTEST_137
#if defined(TEST_137) && __cplusplus >= 201103L #if defined(TEST_137) && __cplusplus >= 201103L
# include <experimental/utility> # include <experimental/vector>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_138 // RUN: %{build} -DTEST_138
#if defined(TEST_138) && __cplusplus >= 201103L #if defined(TEST_138)
# include <experimental/vector> # include <ext/hash_map>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_139 // RUN: %{build} -DTEST_139
#if defined(TEST_139) #if defined(TEST_139)
# include <ext/hash_map>
using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif
// RUN: %{build} -DTEST_140
#if defined(TEST_140)
# include <ext/hash_set> # include <ext/hash_set>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// GENERATED-MARKER // GENERATED-MARKER

libcxx/test/libcxx/clang_tidy.sh.cpp

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <istream> # include <istream>
#endif #endif
#include <iterator> #include <iterator>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <latch> # include <latch>
#endif #endif
#include <limits> #include <limits>
#include <limits.h>
#include <list> #include <list>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale> # include <locale>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale.h> # include <locale.h>
#endif #endif
#include <map> #include <map>
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

libcxx/test/libcxx/double_include.sh.cpp

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <istream> # include <istream>
#endif #endif
#include <iterator> #include <iterator>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <latch> # include <latch>
#endif #endif
#include <limits> #include <limits>
#include <limits.h>
#include <list> #include <list>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale> # include <locale>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale.h> # include <locale.h>
#endif #endif
#include <map> #include <map>
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

Show First 20 Lines • Show All 185 Lines • ▼ Show 20 Lines
#include <iterator> #include <iterator>
TEST_MACROS(); TEST_MACROS();
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <latch> # include <latch>
TEST_MACROS(); TEST_MACROS();
#endif #endif
#include <limits> #include <limits>
TEST_MACROS(); TEST_MACROS();
#include <limits.h>
TEST_MACROS();
#include <list> #include <list>
TEST_MACROS(); TEST_MACROS();
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale> # include <locale>
TEST_MACROS(); TEST_MACROS();
#endif #endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale.h> # include <locale.h>
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

libcxx/test/libcxx/modules_include.sh.cpp

Show First 20 Lines • Show All 298 Lines • ▼ Show 20 Lines
#include <latch> #include <latch>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_63 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_63
#if defined(TEST_63) #if defined(TEST_63)
#include <limits> #include <limits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_64 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_64
#if defined(TEST_64) #if defined(TEST_64)
#include <limits.h> #include <list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_65 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_65
#if defined(TEST_65) #if defined(TEST_65) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <list> #include <locale>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_66 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_66
#if defined(TEST_66) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_66) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <locale> #include <locale.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_67 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_67
#if defined(TEST_67) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_67)
#include <locale.h> #include <map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_68 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_68
#if defined(TEST_68) #if defined(TEST_68)
#include <map> #include <math.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_69 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_69
#if defined(TEST_69) #if defined(TEST_69)
#include <math.h> #include <memory>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_70 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_70
#if defined(TEST_70) #if defined(TEST_70)
#include <memory> #include <memory_resource>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_71 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_71
#if defined(TEST_71) #if defined(TEST_71) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <memory_resource> #include <mutex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_72 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_72
#if defined(TEST_72) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_72)
#include <mutex> #include <new>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_73 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_73
#if defined(TEST_73) #if defined(TEST_73)
#include <new> #include <numbers>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_74 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_74
#if defined(TEST_74) #if defined(TEST_74)
#include <numbers> #include <numeric>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_75 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_75
#if defined(TEST_75) #if defined(TEST_75)
#include <numeric> #include <optional>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_76 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_76
#if defined(TEST_76) #if defined(TEST_76) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <optional> #include <ostream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_77 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_77
#if defined(TEST_77) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_77)
#include <ostream> #include <queue>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_78 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_78
#if defined(TEST_78) #if defined(TEST_78)
#include <queue> #include <random>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_79 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_79
#if defined(TEST_79) #if defined(TEST_79)
#include <random> #include <ranges>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_80 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_80
#if defined(TEST_80) #if defined(TEST_80)
#include <ranges> #include <ratio>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_81 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_81
#if defined(TEST_81) #if defined(TEST_81) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <ratio> #include <regex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_82 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_82
#if defined(TEST_82) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_82)
#include <regex> #include <scoped_allocator>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_83 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_83
#if defined(TEST_83) #if defined(TEST_83) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <scoped_allocator> #include <semaphore>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_84 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_84
#if defined(TEST_84) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_84)
#include <semaphore> #include <set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_85 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_85
#if defined(TEST_85) #if defined(TEST_85)
#include <set> #include <setjmp.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_86 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_86
#if defined(TEST_86) #if defined(TEST_86) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <setjmp.h> #include <shared_mutex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_87 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_87
#if defined(TEST_87) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_87)
#include <shared_mutex> #include <span>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_88 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_88
#if defined(TEST_88) #if defined(TEST_88) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <span> #include <sstream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_89 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_89
#if defined(TEST_89) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_89)
#include <sstream> #include <stack>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_90 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_90
#if defined(TEST_90) #if defined(TEST_90) && __cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS)
#include <stack> #include <stdatomic.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_91 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_91
#if defined(TEST_91) && __cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_91)
#include <stdatomic.h> #include <stdbool.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_92 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_92
#if defined(TEST_92) #if defined(TEST_92)
#include <stdbool.h> #include <stddef.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_93 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_93
#if defined(TEST_93) #if defined(TEST_93)
#include <stddef.h> #include <stdexcept>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_94 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_94
#if defined(TEST_94) #if defined(TEST_94)
#include <stdexcept> #include <stdint.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_95 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_95
#if defined(TEST_95) #if defined(TEST_95)
#include <stdint.h> #include <stdio.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_96 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_96
#if defined(TEST_96) #if defined(TEST_96)
#include <stdio.h> #include <stdlib.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_97 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_97
#if defined(TEST_97) #if defined(TEST_97) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <stdlib.h> #include <streambuf>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_98 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_98
#if defined(TEST_98) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_98)
#include <streambuf> #include <string>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_99 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_99
#if defined(TEST_99) #if defined(TEST_99)
#include <string> #include <string.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_100 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_100
#if defined(TEST_100) #if defined(TEST_100)
#include <string.h> #include <string_view>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_101 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_101
#if defined(TEST_101) #if defined(TEST_101) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <string_view> #include <strstream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_102 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_102
#if defined(TEST_102) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_102)
#include <strstream> #include <system_error>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_103 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_103
#if defined(TEST_103) #if defined(TEST_103)
#include <system_error> #include <tgmath.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_104 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_104
#if defined(TEST_104) #if defined(TEST_104) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <tgmath.h> #include <thread>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_105 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_105
#if defined(TEST_105) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_105)
#include <thread> #include <tuple>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_106 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_106
#if defined(TEST_106) #if defined(TEST_106)
#include <tuple> #include <type_traits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_107 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_107
#if defined(TEST_107) #if defined(TEST_107)
#include <type_traits> #include <typeindex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_108 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_108
#if defined(TEST_108) #if defined(TEST_108)
#include <typeindex> #include <typeinfo>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_109 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_109
#if defined(TEST_109) #if defined(TEST_109)
#include <typeinfo> #include <uchar.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_110 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_110
#if defined(TEST_110) #if defined(TEST_110)
#include <uchar.h> #include <unordered_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_111 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_111
#if defined(TEST_111) #if defined(TEST_111)
#include <unordered_map> #include <unordered_set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_112 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_112
#if defined(TEST_112) #if defined(TEST_112)
#include <unordered_set> #include <utility>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_113 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_113
#if defined(TEST_113) #if defined(TEST_113)
#include <utility> #include <valarray>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_114 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_114
#if defined(TEST_114) #if defined(TEST_114)
#include <valarray> #include <variant>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_115 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_115
#if defined(TEST_115) #if defined(TEST_115)
#include <variant> #include <vector>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_116 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_116
#if defined(TEST_116) #if defined(TEST_116)
#include <vector> #include <version>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_117 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_117
#if defined(TEST_117) #if defined(TEST_117) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
#include <version> #include <wchar.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_118 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_118
#if defined(TEST_118) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if defined(TEST_118) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
#include <wchar.h> #include <wctype.h>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_119 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_119
#if defined(TEST_119) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if defined(TEST_119) && __cplusplus >= 201103L
#include <wctype.h> #include <experimental/algorithm>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_120 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_120
#if defined(TEST_120) && __cplusplus >= 201103L #if defined(TEST_120) && __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
#include <experimental/algorithm> #include <experimental/coroutine>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_121 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_121
#if defined(TEST_121) && __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES) #if defined(TEST_121) && __cplusplus >= 201103L
#include <experimental/coroutine> #include <experimental/deque>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_122 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_122
#if defined(TEST_122) && __cplusplus >= 201103L #if defined(TEST_122) && __cplusplus >= 201103L
#include <experimental/deque> #include <experimental/forward_list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_123 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_123
#if defined(TEST_123) && __cplusplus >= 201103L #if defined(TEST_123) && __cplusplus >= 201103L
#include <experimental/forward_list> #include <experimental/functional>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_124 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_124
#if defined(TEST_124) && __cplusplus >= 201103L #if defined(TEST_124) && __cplusplus >= 201103L
#include <experimental/functional> #include <experimental/iterator>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_125 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_125
#if defined(TEST_125) && __cplusplus >= 201103L #if defined(TEST_125) && __cplusplus >= 201103L
#include <experimental/iterator> #include <experimental/list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_126 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_126
#if defined(TEST_126) && __cplusplus >= 201103L #if defined(TEST_126) && __cplusplus >= 201103L
#include <experimental/list> #include <experimental/map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_127 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_127
#if defined(TEST_127) && __cplusplus >= 201103L #if defined(TEST_127) && __cplusplus >= 201103L
#include <experimental/map> #include <experimental/memory_resource>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_128 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_128
#if defined(TEST_128) && __cplusplus >= 201103L #if defined(TEST_128) && __cplusplus >= 201103L
#include <experimental/memory_resource> #include <experimental/propagate_const>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_129 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_129
#if defined(TEST_129) && __cplusplus >= 201103L #if defined(TEST_129) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
#include <experimental/propagate_const> #include <experimental/regex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_130 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_130
#if defined(TEST_130) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L #if defined(TEST_130) && __cplusplus >= 201103L
#include <experimental/regex> #include <experimental/set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_131 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_131
#if defined(TEST_131) && __cplusplus >= 201103L #if defined(TEST_131) && __cplusplus >= 201103L
#include <experimental/set> #include <experimental/simd>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_132 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_132
#if defined(TEST_132) && __cplusplus >= 201103L #if defined(TEST_132) && __cplusplus >= 201103L
#include <experimental/simd> #include <experimental/string>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_133 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_133
#if defined(TEST_133) && __cplusplus >= 201103L #if defined(TEST_133) && __cplusplus >= 201103L
#include <experimental/string> #include <experimental/type_traits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_134 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_134
#if defined(TEST_134) && __cplusplus >= 201103L #if defined(TEST_134) && __cplusplus >= 201103L
#include <experimental/type_traits> #include <experimental/unordered_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_135 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_135
#if defined(TEST_135) && __cplusplus >= 201103L #if defined(TEST_135) && __cplusplus >= 201103L
#include <experimental/unordered_map> #include <experimental/unordered_set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_136 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_136
#if defined(TEST_136) && __cplusplus >= 201103L #if defined(TEST_136) && __cplusplus >= 201103L
#include <experimental/unordered_set> #include <experimental/utility>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_137 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_137
#if defined(TEST_137) && __cplusplus >= 201103L #if defined(TEST_137) && __cplusplus >= 201103L
#include <experimental/utility> #include <experimental/vector>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_138 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_138
#if defined(TEST_138) && __cplusplus >= 201103L #if defined(TEST_138)
#include <experimental/vector> #include <ext/hash_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_139 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_139
#if defined(TEST_139) #if defined(TEST_139)
#include <ext/hash_map>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_140
#if defined(TEST_140)
#include <ext/hash_set> #include <ext/hash_set>
#endif #endif
// GENERATED-MARKER // GENERATED-MARKER

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

Show First 20 Lines • Show All 240 Lines • ▼ Show 20 Lines
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <istream> # include <istream>
#endif #endif
#include <iterator> #include <iterator>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <latch> # include <latch>
#endif #endif
#include <limits> #include <limits>
#include <limits.h>
#include <list> #include <list>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale> # include <locale>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale.h> # include <locale.h>
#endif #endif
#include <map> #include <map>
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <istream> # include <istream>
#endif #endif
#include <iterator> #include <iterator>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <latch> # include <latch>
#endif #endif
#include <limits> #include <limits>
#include <limits.h>
#include <list> #include <list>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale> # include <locale>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale.h> # include <locale.h>
#endif #endif
#include <map> #include <map>
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/libcxx/transitive_includes.sh.cpp

Show First 20 Lines • Show All 306 Lines • ▼ Show 20 Lines
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_62 2> %t/header.latch // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_62 2> %t/header.latch
#if defined(TEST_62) #if defined(TEST_62)
#include <latch> #include <latch>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_63 2> %t/header.limits // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_63 2> %t/header.limits
#if defined(TEST_63) #if defined(TEST_63)
#include <limits> #include <limits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_65 2> %t/header.list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_64 2> %t/header.list
#if defined(TEST_65) #if defined(TEST_64)
#include <list> #include <list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_66 2> %t/header.locale // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_65 2> %t/header.locale
#if defined(TEST_66) #if defined(TEST_65)
#include <locale> #include <locale>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_68 2> %t/header.map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_67 2> %t/header.map
#if defined(TEST_68) #if defined(TEST_67)
#include <map> #include <map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_70 2> %t/header.memory // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_69 2> %t/header.memory
#if defined(TEST_70) #if defined(TEST_69)
#include <memory> #include <memory>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_71 2> %t/header.memory_resource // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_70 2> %t/header.memory_resource
#if defined(TEST_71) #if defined(TEST_70)
#include <memory_resource> #include <memory_resource>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_72 2> %t/header.mutex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_71 2> %t/header.mutex
#if defined(TEST_72) #if defined(TEST_71)
#include <mutex> #include <mutex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_73 2> %t/header.new // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_72 2> %t/header.new
#if defined(TEST_73) #if defined(TEST_72)
#include <new> #include <new>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_74 2> %t/header.numbers // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_73 2> %t/header.numbers
#if defined(TEST_74) #if defined(TEST_73)
#include <numbers> #include <numbers>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_75 2> %t/header.numeric // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_74 2> %t/header.numeric
#if defined(TEST_75) #if defined(TEST_74)
#include <numeric> #include <numeric>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_76 2> %t/header.optional // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_75 2> %t/header.optional
#if defined(TEST_76) #if defined(TEST_75)
#include <optional> #include <optional>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_77 2> %t/header.ostream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_76 2> %t/header.ostream
#if defined(TEST_77) #if defined(TEST_76)
#include <ostream> #include <ostream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_78 2> %t/header.queue // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_77 2> %t/header.queue
#if defined(TEST_78) #if defined(TEST_77)
#include <queue> #include <queue>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_79 2> %t/header.random // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_78 2> %t/header.random
#if defined(TEST_79) #if defined(TEST_78)
#include <random> #include <random>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_80 2> %t/header.ranges // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_79 2> %t/header.ranges
#if defined(TEST_80) #if defined(TEST_79)
#include <ranges> #include <ranges>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_81 2> %t/header.ratio // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_80 2> %t/header.ratio
#if defined(TEST_81) #if defined(TEST_80)
#include <ratio> #include <ratio>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_82 2> %t/header.regex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_81 2> %t/header.regex
#if defined(TEST_82) #if defined(TEST_81)
#include <regex> #include <regex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_83 2> %t/header.scoped_allocator // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_82 2> %t/header.scoped_allocator
#if defined(TEST_83) #if defined(TEST_82)
#include <scoped_allocator> #include <scoped_allocator>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_84 2> %t/header.semaphore // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_83 2> %t/header.semaphore
#if defined(TEST_84) #if defined(TEST_83)
#include <semaphore> #include <semaphore>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_85 2> %t/header.set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_84 2> %t/header.set
#if defined(TEST_85) #if defined(TEST_84)
#include <set> #include <set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_87 2> %t/header.shared_mutex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_86 2> %t/header.shared_mutex
#if defined(TEST_87) #if defined(TEST_86)
#include <shared_mutex> #include <shared_mutex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_88 2> %t/header.span // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_87 2> %t/header.span
#if defined(TEST_88) #if defined(TEST_87)
#include <span> #include <span>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_89 2> %t/header.sstream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_88 2> %t/header.sstream
#if defined(TEST_89) #if defined(TEST_88)
#include <sstream> #include <sstream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_90 2> %t/header.stack // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_89 2> %t/header.stack
#if defined(TEST_90) #if defined(TEST_89)
#include <stack> #include <stack>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_94 2> %t/header.stdexcept // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_93 2> %t/header.stdexcept
#if defined(TEST_94) #if defined(TEST_93)
#include <stdexcept> #include <stdexcept>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_98 2> %t/header.streambuf // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_97 2> %t/header.streambuf
#if defined(TEST_98) #if defined(TEST_97)
#include <streambuf> #include <streambuf>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_99 2> %t/header.string // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_98 2> %t/header.string
#if defined(TEST_99) #if defined(TEST_98)
#include <string> #include <string>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_101 2> %t/header.string_view // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_100 2> %t/header.string_view
#if defined(TEST_101) #if defined(TEST_100)
#include <string_view> #include <string_view>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_102 2> %t/header.strstream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_101 2> %t/header.strstream
#if defined(TEST_102) #if defined(TEST_101)
#include <strstream> #include <strstream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_103 2> %t/header.system_error // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_102 2> %t/header.system_error
#if defined(TEST_103) #if defined(TEST_102)
#include <system_error> #include <system_error>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_105 2> %t/header.thread // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_104 2> %t/header.thread
#if defined(TEST_105) #if defined(TEST_104)
#include <thread> #include <thread>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_106 2> %t/header.tuple // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_105 2> %t/header.tuple
#if defined(TEST_106) #if defined(TEST_105)
#include <tuple> #include <tuple>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_107 2> %t/header.type_traits // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_106 2> %t/header.type_traits
#if defined(TEST_107) #if defined(TEST_106)
#include <type_traits> #include <type_traits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_108 2> %t/header.typeindex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_107 2> %t/header.typeindex
#if defined(TEST_108) #if defined(TEST_107)
#include <typeindex> #include <typeindex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_109 2> %t/header.typeinfo // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_108 2> %t/header.typeinfo
#if defined(TEST_109) #if defined(TEST_108)
#include <typeinfo> #include <typeinfo>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_111 2> %t/header.unordered_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_110 2> %t/header.unordered_map
#if defined(TEST_111) #if defined(TEST_110)
#include <unordered_map> #include <unordered_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_112 2> %t/header.unordered_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_111 2> %t/header.unordered_set
#if defined(TEST_112) #if defined(TEST_111)
#include <unordered_set> #include <unordered_set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_113 2> %t/header.utility // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_112 2> %t/header.utility
#if defined(TEST_113) #if defined(TEST_112)
#include <utility> #include <utility>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_114 2> %t/header.valarray // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_113 2> %t/header.valarray
#if defined(TEST_114) #if defined(TEST_113)
#include <valarray> #include <valarray>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_115 2> %t/header.variant // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_114 2> %t/header.variant
#if defined(TEST_115) #if defined(TEST_114)
#include <variant> #include <variant>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_116 2> %t/header.vector // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_115 2> %t/header.vector
#if defined(TEST_116) #if defined(TEST_115)
#include <vector> #include <vector>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_117 2> %t/header.version // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_116 2> %t/header.version
#if defined(TEST_117) #if defined(TEST_116)
#include <version> #include <version>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_120 2> %t/header.experimental_algorithm // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_119 2> %t/header.experimental_algorithm
#if defined(TEST_120) #if defined(TEST_119)
#include <experimental/algorithm> #include <experimental/algorithm>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_121 2> %t/header.experimental_coroutine // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_120 2> %t/header.experimental_coroutine
#if defined(TEST_121) #if defined(TEST_120)
#include <experimental/coroutine> #include <experimental/coroutine>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_122 2> %t/header.experimental_deque // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_121 2> %t/header.experimental_deque
#if defined(TEST_122) #if defined(TEST_121)
#include <experimental/deque> #include <experimental/deque>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_123 2> %t/header.experimental_forward_list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_122 2> %t/header.experimental_forward_list
#if defined(TEST_123) #if defined(TEST_122)
#include <experimental/forward_list> #include <experimental/forward_list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_124 2> %t/header.experimental_functional // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_123 2> %t/header.experimental_functional
#if defined(TEST_124) #if defined(TEST_123)
#include <experimental/functional> #include <experimental/functional>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_125 2> %t/header.experimental_iterator // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_124 2> %t/header.experimental_iterator
#if defined(TEST_125) #if defined(TEST_124)
#include <experimental/iterator> #include <experimental/iterator>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_126 2> %t/header.experimental_list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_125 2> %t/header.experimental_list
#if defined(TEST_126) #if defined(TEST_125)
#include <experimental/list> #include <experimental/list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_127 2> %t/header.experimental_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_126 2> %t/header.experimental_map
#if defined(TEST_127) #if defined(TEST_126)
#include <experimental/map> #include <experimental/map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_128 2> %t/header.experimental_memory_resource // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_127 2> %t/header.experimental_memory_resource
#if defined(TEST_128) #if defined(TEST_127)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_129 2> %t/header.experimental_propagate_const // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_128 2> %t/header.experimental_propagate_const
#if defined(TEST_129) #if defined(TEST_128)
#include <experimental/propagate_const> #include <experimental/propagate_const>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_130 2> %t/header.experimental_regex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_129 2> %t/header.experimental_regex
#if defined(TEST_130) #if defined(TEST_129)
#include <experimental/regex> #include <experimental/regex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_131 2> %t/header.experimental_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_130 2> %t/header.experimental_set
#if defined(TEST_131) #if defined(TEST_130)
#include <experimental/set> #include <experimental/set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_132 2> %t/header.experimental_simd // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_131 2> %t/header.experimental_simd
#if defined(TEST_132) #if defined(TEST_131)
#include <experimental/simd> #include <experimental/simd>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_133 2> %t/header.experimental_string // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_132 2> %t/header.experimental_string
#if defined(TEST_133) #if defined(TEST_132)
#include <experimental/string> #include <experimental/string>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_134 2> %t/header.experimental_type_traits // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_133 2> %t/header.experimental_type_traits
#if defined(TEST_134) #if defined(TEST_133)
#include <experimental/type_traits> #include <experimental/type_traits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_135 2> %t/header.experimental_unordered_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_134 2> %t/header.experimental_unordered_map
#if defined(TEST_135) #if defined(TEST_134)
#include <experimental/unordered_map> #include <experimental/unordered_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_136 2> %t/header.experimental_unordered_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_135 2> %t/header.experimental_unordered_set
#if defined(TEST_136) #if defined(TEST_135)
#include <experimental/unordered_set> #include <experimental/unordered_set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_137 2> %t/header.experimental_utility // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_136 2> %t/header.experimental_utility
#if defined(TEST_137) #if defined(TEST_136)
#include <experimental/utility> #include <experimental/utility>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_138 2> %t/header.experimental_vector // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_137 2> %t/header.experimental_vector
#if defined(TEST_138) #if defined(TEST_137)
#include <experimental/vector> #include <experimental/vector>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_139 2> %t/header.ext_hash_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_138 2> %t/header.ext_hash_map
#if defined(TEST_139) #if defined(TEST_138)
#include <ext/hash_map> #include <ext/hash_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_140 2> %t/header.ext_hash_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_139 2> %t/header.ext_hash_set
#if defined(TEST_140) #if defined(TEST_139)
#include <ext/hash_set> #include <ext/hash_set>
#endif #endif
// RUN: %{python} %S/transitive_includes_to_csv.py %t > %t/transitive_includes.csv // RUN: %{python} %S/transitive_includes_to_csv.py %t > %t/transitive_includes.csv
// RUN: diff -w %S/transitive_includes/%{cxx_std}.csv %t/transitive_includes.csv // RUN: diff -w %S/transitive_includes/%{cxx_std}.csv %t/transitive_includes.csv
// GENERATED-MARKER // GENERATED-MARKER