[libc++] Consistently guard "#pragma clang" with "#if defined(__clang__)".

[STL_MSFT]

Summary

[libc++] Consistently guard "#pragma clang" with "#if defined(clang)".

Similarly, consistently guard "#pragma GCC" with "#if defined(GNUC)".

Fixes MSVC "warning C4068: unknown pragma".

[EricWF]

Committed in r267836. I must say it's pretty cool to review and commit a patch from *the* STL. Never thought that would happen when I started programming.

test/std/depr/depr.c.headers/stdio_h.pass.cpp

 #endif
 
 #ifndef stdout
 #error stdout not defined
 #endif
 
 #include <cstdarg>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wformat-zero-length"
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" // for tmpnam
+#endif
 
 int main()
 {
     FILE* fp = 0;
     fpos_t fpos = {0};
     size_t s = 0; ((void)s);
     char* cp = 0;
     char arr[] = {'a', 'b'};

test/std/depr/depr.c.headers/wchar_h.pass.cpp

 #endif
 
 int main()
 {
 // mbstate_t comes from the underlying C library; it is defined (in C99) as:
 //    a complete object type other than an array type that can hold the conversion 
 //    state information necessary to convert between sequences of multibyte 
 //    characters and wide characters
+#if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wmissing-braces"
+#endif
     mbstate_t mb = {0};
+#if defined(__clang__)
 #pragma clang diagnostic pop
+#endif
 
     size_t s = 0;
     tm *tm = 0;
     wint_t w = 0;
     ::FILE* fp = 0;
 #ifdef __APPLE__
     __darwin_va_list va;
 #else

test/std/input.output/file.streams/c.files/cstdio.pass.cpp

 #endif
 
 #ifndef stdout
 #error stdout not defined
 #endif
 
 #include <cstdarg>
 
+#if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wformat-zero-length"
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
 
 int main()
 {
     std::FILE* fp = 0;
     std::fpos_t fpos = {0};
     std::size_t s = 0;
     char* cp = 0;
     std::va_list va;

test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp

 //                     typename basic_string<charT>::size_type n = basic_string<charT>::npos,
 //                     charT zero = charT('0'), charT one = charT('1'));
 
 #include <bitset>
 #include <cassert>
 #include <algorithm> // for 'min' and 'max'
 #include <stdexcept> // for 'invalid_argument'
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_char_pointer_ctor()
 {
     {
     try
     {
         std::bitset<N> v("xxx1010101010xxxx");

test/std/utilities/template.bitset/bitset.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test default ctor
 
 #include <bitset>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_default_ctor()
 {
     {
     _LIBCPP_CONSTEXPR std::bitset<N> v1;
     assert(v1.size() == N);
     for (std::size_t i = 0; i < N; ++i)

test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp

 // XFAIL: libcpp-no-exceptions
 // test bitset(string, pos, n, zero, one);
 
 #include <bitset>
 #include <cassert>
 #include <algorithm> // for 'min' and 'max'
 #include <stdexcept> // for 'invalid_argument'
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_string_ctor()
 {
     {
     try
     {
         std::string str("xxx1010101010xxxx");

test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset(unsigned long long val);
 
 #include <bitset>
 #include <cassert>
 #include <algorithm> // for 'min' and 'max'
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_val_ctor()
 {
     {
     _LIBCPP_CONSTEXPR std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
     assert(v.size() == N);
     unsigned M = std::min<std::size_t>(N, 64);

test/std/utilities/template.bitset/bitset.members/count.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test size_t count() const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& flip();
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
 // test bitset<N>& flip(size_t pos);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/index.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>::reference operator[](size_t pos);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test constexpr bool operator[](size_t pos) const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N> operator<<(size_t pos) const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& operator<<=(size_t pos);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N> operator~() const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& operator&=(const bitset<N>& rhs);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp

 
 // bool operator==(const bitset<N>& rhs) const;
 // bool operator!=(const bitset<N>& rhs) const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& operator|=(const bitset<N>& rhs);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& operator^=(const bitset<N>& rhs);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& reset();
 
 #include <bitset>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_reset_all()
 {
     std::bitset<N> v;
     v.set();
     v.reset();
     for (std::size_t i = 0; i < N; ++i)

test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
 // test bitset<N>& reset(size_t pos);
 
 #include <bitset>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_reset_one()
 {
     std::bitset<N> v;
     try
     {
         v.set();

test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N> operator>>(size_t pos) const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& operator<<=(size_t pos);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>& set();
 
 #include <bitset>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_set_all()
 {
     std::bitset<N> v;
     v.set();
     for (std::size_t i = 0; i < N; ++i)
         assert(v[i]);

test/std/utilities/template.bitset/bitset.members/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
 // test constexpr bool test(size_t pos) const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp

 //
 // basic_string<char, char_traits<char>, allocator<char> > to_string() const;
 
 #include <bitset>
 #include <string>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N> operator^(const bitset<N>& lhs, const bitset<N>& rhs);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N> operator|(const bitset<N>& lhs, const bitset<N>& rhs);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);

test/support/disable_missing_braces_warning.h

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_DISABLE_MISSING_BRACES_WARNING_H
 #define SUPPORT_DISABLE_MISSING_BRACES_WARNING_H
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
+#if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wmissing-braces"
+#endif
 
 #endif // SUPPORT_DISABLE_MISSING_BRACES_WARNING_H