Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-09-15 15:41
📄 atomic_word.h // Low-level type for atomic operations -- C++ -- // Copyright (C) 2004-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file atomic_word.h * This file is a GNU extension to the Standard C++ Library. */ #ifndef _GLIBCXX_ATOMIC_WORD_H #define _GLIBCXX_ATOMIC_WORD_H 1 typedef int _Atomic_word; // This is a memory order acquire fence. #define _GLIBCXX_READ_MEM_BARRIER __atomic_thread_fence (__ATOMIC_ACQUIRE) // This is a memory order release fence. #define _GLIBCXX_WRITE_MEM_BARRIER __atomic_thread_fence (__ATOMIC_RELEASE) #endif	1.48 KB	2025-09-15 15:41
📄 basic_file.h // Wrapper of C-language FILE struct -- C++ -- // Copyright (C) 2000-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. // // ISO C++ 14882: 27.8 File-based streams // /** @file bits/basic_file.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{ios} / #ifndef _GLIBCXX_BASIC_FILE_STDIO_H #define _GLIBCXX_BASIC_FILE_STDIO_H 1 #pragma GCC system_header #include <bits/c++config.h> #include <bits/c++io.h> // for __c_lock and __c_file #include <bits/move.h> // for swap #include <ios> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // Generic declaration. template<typename _CharT> class __basic_file; // Specialization. template<> class __basic_file<char> { // Underlying data source/sink. __c_file _M_cfile; // True iff we opened _M_cfile, and thus must close it ourselves. bool _M_cfile_created; public: __basic_file(__c_lock* __lock = 0) throw (); #if __cplusplus >= 201103L __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created) { __rv._M_cfile = nullptr; __rv._M_cfile_created = false; } __basic_file& operator=(const __basic_file&) = delete; __basic_file& operator=(__basic_file&&) = delete; void swap(__basic_file& __f) noexcept { std::swap(_M_cfile, __f._M_cfile); std::swap(_M_cfile_created, __f._M_cfile_created); } #endif __basic_file* open(const char* __name, ios_base::openmode __mode, int __prot = 0664); #if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T __basic_file* open(const wchar_t* __name, ios_base::openmode __mode); #endif __basic_file* sys_open(__c_file* __file, ios_base::openmode); __basic_file* sys_open(int __fd, ios_base::openmode __mode) throw (); __basic_file* close(); _GLIBCXX_PURE bool is_open() const throw (); _GLIBCXX_PURE int fd() throw (); _GLIBCXX_PURE __c_file* file() throw (); ~__basic_file(); streamsize xsputn(const char* __s, streamsize __n); streamsize xsputn_2(const char* __s1, streamsize __n1, const char* __s2, streamsize __n2); streamsize xsgetn(char* __s, streamsize __n); streamoff seekoff(streamoff __off, ios_base::seekdir __way) throw (); int sync(); streamsize showmanyc(); }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif	3.49 KB	2025-09-15 15:41
📄 c++allocator.h // Base to std::allocator -- C++ -- // Copyright (C) 2004-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/c++allocator.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{memory} / #ifndef _GLIBCXX_CXX_ALLOCATOR_H #define _GLIBCXX_CXX_ALLOCATOR_H 1 #include <ext/new_allocator.h> #if __cplusplus >= 201103L namespace std { /* * @brief An alias to the base class for std::allocator. * * Used to set the std::allocator base class to * __gnu_cxx::new_allocator. * * @ingroup allocators * @tparam _Tp Type of allocated object. */ template<typename _Tp> using __allocator_base = __gnu_cxx::new_allocator<_Tp>; } #else // Define new_allocator as the base class to std::allocator. # define __allocator_base __gnu_cxx::new_allocator #endif #ifndef _GLIBCXX_SANITIZE_STD_ALLOCATOR # if defined(__SANITIZE_ADDRESS__) # define _GLIBCXX_SANITIZE_STD_ALLOCATOR 1 # elif defined __has_feature # if __has_feature(address_sanitizer) # define _GLIBCXX_SANITIZE_STD_ALLOCATOR 1 # endif # endif #endif #endif	2.06 KB	2025-09-15 15:41
📄 c++config.h // Predefined symbols and macros -- C++ -- // Copyright (C) 1997-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/c++config.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{version} / #ifndef _GLIBCXX_CXX_CONFIG_H #define _GLIBCXX_CXX_CONFIG_H 1 // The major release number for the GCC release the C++ library belongs to. #define _GLIBCXX_RELEASE 11 // The datestamp of the C++ library in compressed ISO date format. #define __GLIBCXX__ 20240719 // Macros for various attributes. // _GLIBCXX_PURE // _GLIBCXX_CONST // _GLIBCXX_NORETURN // _GLIBCXX_NOTHROW // _GLIBCXX_VISIBILITY #ifndef _GLIBCXX_PURE # define _GLIBCXX_PURE __attribute__ ((__pure__)) #endif #ifndef _GLIBCXX_CONST # define _GLIBCXX_CONST __attribute__ ((__const__)) #endif #ifndef _GLIBCXX_NORETURN # define _GLIBCXX_NORETURN __attribute__ ((__noreturn__)) #endif // See below for C++ #ifndef _GLIBCXX_NOTHROW # ifndef __cplusplus # define _GLIBCXX_NOTHROW __attribute__((__nothrow__)) # endif #endif // Macros for visibility attributes. // _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY // _GLIBCXX_VISIBILITY # define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1 #if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY # define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) #else // If this is not supplied by the OS-specific or CPU-specific // headers included below, it will be defined to an empty default. # define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V) #endif // Macros for deprecated attributes. // _GLIBCXX_USE_DEPRECATED // _GLIBCXX_DEPRECATED // _GLIBCXX_DEPRECATED_SUGGEST( string-literal ) // _GLIBCXX11_DEPRECATED // _GLIBCXX11_DEPRECATED_SUGGEST( string-literal ) // _GLIBCXX17_DEPRECATED // _GLIBCXX17_DEPRECATED_SUGGEST( string-literal ) // _GLIBCXX20_DEPRECATED( string-literal ) // _GLIBCXX20_DEPRECATED_SUGGEST( string-literal ) #ifndef _GLIBCXX_USE_DEPRECATED # define _GLIBCXX_USE_DEPRECATED 1 #endif #if defined(__DEPRECATED) # define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__)) # define _GLIBCXX_DEPRECATED_SUGGEST(ALT) \ __attribute__ ((__deprecated__ ("use '" ALT "' instead"))) #else # define _GLIBCXX_DEPRECATED # define _GLIBCXX_DEPRECATED_SUGGEST(ALT) #endif #if defined(__DEPRECATED) && (__cplusplus >= 201103L) # define _GLIBCXX11_DEPRECATED _GLIBCXX_DEPRECATED # define _GLIBCXX11_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) #else # define _GLIBCXX11_DEPRECATED # define _GLIBCXX11_DEPRECATED_SUGGEST(ALT) #endif #if defined(__DEPRECATED) && (__cplusplus >= 201703L) # define _GLIBCXX17_DEPRECATED [[__deprecated__]] # define _GLIBCXX17_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) #else # define _GLIBCXX17_DEPRECATED # define _GLIBCXX17_DEPRECATED_SUGGEST(ALT) #endif #if defined(__DEPRECATED) && (__cplusplus > 201703L) # define _GLIBCXX20_DEPRECATED(MSG) [[deprecated(MSG)]] # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) #else # define _GLIBCXX20_DEPRECATED(MSG) # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) #endif // Macros for ABI tag attributes. #ifndef _GLIBCXX_ABI_TAG_CXX11 # define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11"))) #endif // Macro to warn about unused results. #if __cplusplus >= 201703L # define _GLIBCXX_NODISCARD [[__nodiscard__]] #else # define _GLIBCXX_NODISCARD #endif #if __cplusplus // Macro for constexpr, to support in mixed 03/0x mode. #ifndef _GLIBCXX_CONSTEXPR # if __cplusplus >= 201103L # define _GLIBCXX_CONSTEXPR constexpr # define _GLIBCXX_USE_CONSTEXPR constexpr # else # define _GLIBCXX_CONSTEXPR # define _GLIBCXX_USE_CONSTEXPR const # endif #endif #ifndef _GLIBCXX14_CONSTEXPR # if __cplusplus >= 201402L # define _GLIBCXX14_CONSTEXPR constexpr # else # define _GLIBCXX14_CONSTEXPR # endif #endif #ifndef _GLIBCXX17_CONSTEXPR # if __cplusplus >= 201703L # define _GLIBCXX17_CONSTEXPR constexpr # else # define _GLIBCXX17_CONSTEXPR # endif #endif #ifndef _GLIBCXX20_CONSTEXPR # if __cplusplus > 201703L # define _GLIBCXX20_CONSTEXPR constexpr # else # define _GLIBCXX20_CONSTEXPR # endif #endif #ifndef _GLIBCXX17_INLINE # if __cplusplus >= 201703L # define _GLIBCXX17_INLINE inline # else # define _GLIBCXX17_INLINE # endif #endif // Macro for noexcept, to support in mixed 03/0x mode. #ifndef _GLIBCXX_NOEXCEPT # if __cplusplus >= 201103L # define _GLIBCXX_NOEXCEPT noexcept # define _GLIBCXX_NOEXCEPT_IF(...) noexcept(__VA_ARGS__) # define _GLIBCXX_USE_NOEXCEPT noexcept # define _GLIBCXX_THROW(_EXC) # else # define _GLIBCXX_NOEXCEPT # define _GLIBCXX_NOEXCEPT_IF(...) # define _GLIBCXX_USE_NOEXCEPT throw() # define _GLIBCXX_THROW(_EXC) throw(_EXC) # endif #endif #ifndef _GLIBCXX_NOTHROW # define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT #endif #ifndef _GLIBCXX_THROW_OR_ABORT # if __cpp_exceptions # define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC)) # else # define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort()) # endif #endif #if __cpp_noexcept_function_type #define _GLIBCXX_NOEXCEPT_PARM , bool _NE #define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE) #else #define _GLIBCXX_NOEXCEPT_PARM #define _GLIBCXX_NOEXCEPT_QUAL #endif // Macro for extern template, ie controlling template linkage via use // of extern keyword on template declaration. As documented in the g++ // manual, it inhibits all implicit instantiations and is used // throughout the library to avoid multiple weak definitions for // required types that are already explicitly instantiated in the // library binary. This substantially reduces the binary size of // resulting executables. // Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern // templates only in basic_string, thus activating its debug-mode // checks even at -O0. # define _GLIBCXX_EXTERN_TEMPLATE 1 / Outline of libstdc++ namespaces. namespace std { namespace __debug { } namespace __parallel { } namespace __cxx1998 { } namespace __detail { namespace __variant { } // C++17 } namespace rel_ops { } namespace tr1 { namespace placeholders { } namespace regex_constants { } namespace __detail { } } namespace tr2 { } namespace decimal { } namespace chrono { } // C++11 namespace placeholders { } // C++11 namespace regex_constants { } // C++11 namespace this_thread { } // C++11 inline namespace literals { // C++14 inline namespace chrono_literals { } // C++14 inline namespace complex_literals { } // C++14 inline namespace string_literals { } // C++14 inline namespace string_view_literals { } // C++17 } } namespace abi { } namespace __gnu_cxx { namespace __detail { } } For full details see: http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html / namespace std { typedef __SIZE_TYPE__ size_t; typedef __PTRDIFF_TYPE__ ptrdiff_t; #if __cplusplus >= 201103L typedef decltype(nullptr) nullptr_t; #endif } # define _GLIBCXX_USE_DUAL_ABI 1 #if ! _GLIBCXX_USE_DUAL_ABI // Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI # undef _GLIBCXX_USE_CXX11_ABI #endif #ifndef _GLIBCXX_USE_CXX11_ABI # define _GLIBCXX_USE_CXX11_ABI 1 #endif #if _GLIBCXX_USE_CXX11_ABI namespace std { inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } } namespace __gnu_cxx { inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } } # define _GLIBCXX_NAMESPACE_CXX11 __cxx11:: # define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 { # define _GLIBCXX_END_NAMESPACE_CXX11 } # define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11 #else # define _GLIBCXX_NAMESPACE_CXX11 # define _GLIBCXX_BEGIN_NAMESPACE_CXX11 # define _GLIBCXX_END_NAMESPACE_CXX11 # define _GLIBCXX_DEFAULT_ABI_TAG #endif // Defined if inline namespaces are used for versioning. # define _GLIBCXX_INLINE_VERSION 0 // Inline namespace for symbol versioning. #if _GLIBCXX_INLINE_VERSION # define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 { # define _GLIBCXX_END_NAMESPACE_VERSION } namespace std { inline _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201402L inline namespace literals { inline namespace chrono_literals { } inline namespace complex_literals { } inline namespace string_literals { } #if __cplusplus > 201402L inline namespace string_view_literals { } #endif // C++17 } #endif // C++14 _GLIBCXX_END_NAMESPACE_VERSION } namespace __gnu_cxx { inline _GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_END_NAMESPACE_VERSION } #else # define _GLIBCXX_BEGIN_NAMESPACE_VERSION # define _GLIBCXX_END_NAMESPACE_VERSION #endif // Inline namespaces for special modes: debug, parallel. #if defined(_GLIBCXX_DEBUG) \|\| defined(_GLIBCXX_PARALLEL) namespace std { _GLIBCXX_BEGIN_NAMESPACE_VERSION // Non-inline namespace for components replaced by alternates in active mode. namespace __cxx1998 { # if _GLIBCXX_USE_CXX11_ABI inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } # endif } _GLIBCXX_END_NAMESPACE_VERSION // Inline namespace for debug mode. # ifdef _GLIBCXX_DEBUG inline namespace __debug { } # endif // Inline namespaces for parallel mode. # ifdef _GLIBCXX_PARALLEL inline namespace __parallel { } # endif } // Check for invalid usage and unsupported mixed-mode use. # if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL) # error illegal use of multiple inlined namespaces # endif // Check for invalid use due to lack for weak symbols. # if __NO_INLINE__ && !__GXX_WEAK__ # warning currently using inlined namespace mode which may fail \ without inlining due to lack of weak symbols # endif #endif // Macros for namespace scope. Either namespace std:: or the name // of some nested namespace within it corresponding to the active mode. // _GLIBCXX_STD_A // _GLIBCXX_STD_C // // Macros for opening/closing conditional namespaces. // _GLIBCXX_BEGIN_NAMESPACE_ALGO // _GLIBCXX_END_NAMESPACE_ALGO // _GLIBCXX_BEGIN_NAMESPACE_CONTAINER // _GLIBCXX_END_NAMESPACE_CONTAINER #if defined(_GLIBCXX_DEBUG) # define _GLIBCXX_STD_C __cxx1998 # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \ namespace _GLIBCXX_STD_C { # define _GLIBCXX_END_NAMESPACE_CONTAINER } #else # define _GLIBCXX_STD_C std # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER # define _GLIBCXX_END_NAMESPACE_CONTAINER #endif #ifdef _GLIBCXX_PARALLEL # define _GLIBCXX_STD_A __cxx1998 # define _GLIBCXX_BEGIN_NAMESPACE_ALGO \ namespace _GLIBCXX_STD_A { # define _GLIBCXX_END_NAMESPACE_ALGO } #else # define _GLIBCXX_STD_A std # define _GLIBCXX_BEGIN_NAMESPACE_ALGO # define _GLIBCXX_END_NAMESPACE_ALGO #endif // GLIBCXX_ABI Deprecated // Define if compatibility should be provided for -mlong-double-64. #undef _GLIBCXX_LONG_DOUBLE_COMPAT // Define if compatibility should be provided for alternative 128-bit long // double formats. Not possible for Clang until __ibm128 is supported. #ifndef __clang__ #undef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT #endif // Inline namespaces for long double 128 modes. #if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \ && defined __LONG_DOUBLE_IEEE128__ namespace std { // Namespaces for 128-bit IEEE long double format on 64-bit POWER LE. inline namespace __gnu_cxx_ieee128 { } inline namespace __gnu_cxx11_ieee128 { } } # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ieee128:: # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ieee128 { # define _GLIBCXX_END_NAMESPACE_LDBL } # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 __gnu_cxx11_ieee128:: # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 namespace __gnu_cxx11_ieee128 { # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 } #else // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ namespace std { inline namespace __gnu_cxx_ldbl128 { } } # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128:: # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 { # define _GLIBCXX_END_NAMESPACE_LDBL } #else # define _GLIBCXX_NAMESPACE_LDBL # define _GLIBCXX_BEGIN_NAMESPACE_LDBL # define _GLIBCXX_END_NAMESPACE_LDBL #endif #if _GLIBCXX_USE_CXX11_ABI # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11 # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11 #else # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL #endif #endif // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128 // Debug Mode implies checking assertions. #if defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_ASSERTIONS) # define _GLIBCXX_ASSERTIONS 1 #endif // Disable std::string explicit instantiation declarations in order to assert. #ifdef _GLIBCXX_ASSERTIONS # undef _GLIBCXX_EXTERN_TEMPLATE # define _GLIBCXX_EXTERN_TEMPLATE -1 #endif #if __has_builtin(__builtin_is_constant_evaluated) # define __glibcxx_constexpr_assert(cond) \ if (__builtin_is_constant_evaluated() && !bool(cond)) \ __builtin_unreachable() / precondition violation detected! / #else # define __glibcxx_constexpr_assert(unevaluated) #endif // Assert. #if defined(_GLIBCXX_ASSERTIONS) \ \|\| defined(_GLIBCXX_PARALLEL) \|\| defined(_GLIBCXX_PARALLEL_ASSERTIONS) namespace std { // Avoid the use of assert, because we're trying to keep the <cassert> // include out of the mix. extern "C++" _GLIBCXX_NORETURN inline void __replacement_assert(const char __file, int __line, const char* __function, const char* __condition) { __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line, __function, __condition); __builtin_abort(); } } #define __glibcxx_assert_impl(_Condition) \ if (__builtin_expect(!bool(_Condition), false)) \ { \ __glibcxx_constexpr_assert(_Condition); \ std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \ #_Condition); \ } #endif #if defined(_GLIBCXX_ASSERTIONS) # define __glibcxx_assert(cond) \ do { __glibcxx_assert_impl(cond); } while (false) #else # define __glibcxx_assert(cond) \ do { __glibcxx_constexpr_assert(cond); } while (false) #endif // Macros for race detectors. // _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and // _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain // atomic (lock-free) synchronization to race detectors: // the race detector will infer a happens-before arc from the former to the // latter when they share the same argument pointer. // // The most frequent use case for these macros (and the only case in the // current implementation of the library) is atomic reference counting: // void _M_remove_reference() // { // _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount); // if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) // { // _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount); // _M_destroy(__a); // } // } // The annotations in this example tell the race detector that all memory // accesses occurred when the refcount was positive do not race with // memory accesses which occurred after the refcount became zero. #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE # define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) #endif #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER # define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) #endif // Macros for C linkage: define extern "C" linkage only when using C++. # define _GLIBCXX_BEGIN_EXTERN_C extern "C" { # define _GLIBCXX_END_EXTERN_C } # define _GLIBCXX_USE_ALLOCATOR_NEW 1 #ifdef __SIZEOF_INT128__ #if ! defined __GLIBCXX_TYPE_INT_N_0 && ! defined __STRICT_ANSI__ // If __int128 is supported, we expect __GLIBCXX_TYPE_INT_N_0 to be defined // unless the compiler is in strict mode. If it's not defined and the strict // macro is not defined, something is wrong. #warning "__STRICT_ANSI__ seems to have been undefined; this is not supported" #endif #endif #else // !__cplusplus # define _GLIBCXX_BEGIN_EXTERN_C # define _GLIBCXX_END_EXTERN_C #endif // First includes. // Pick up any OS-specific definitions. #include <bits/os_defines.h> // Pick up any CPU-specific definitions. #include <bits/cpu_defines.h> // If platform uses neither visibility nor psuedo-visibility, // specify empty default for namespace annotation macros. #ifndef _GLIBCXX_PSEUDO_VISIBILITY # define _GLIBCXX_PSEUDO_VISIBILITY(V) #endif // Certain function definitions that are meant to be overridable from // user code are decorated with this macro. For some targets, this // macro causes these definitions to be weak. #ifndef _GLIBCXX_WEAK_DEFINITION # define _GLIBCXX_WEAK_DEFINITION #endif // By default, we assume that __GXX_WEAK__ also means that there is support // for declaring functions as weak while not defining such functions. This // allows for referring to functions provided by other libraries (e.g., // libitm) without depending on them if the respective features are not used. #ifndef _GLIBCXX_USE_WEAK_REF # define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__ #endif // Conditionally enable annotations for the Transactional Memory TS on C++11. // Most of the following conditions are due to limitations in the current // implementation. #if __cplusplus >= 201103L && _GLIBCXX_USE_CXX11_ABI \ && _GLIBCXX_USE_DUAL_ABI && __cpp_transactional_memory >= 201500L \ && !_GLIBCXX_FULLY_DYNAMIC_STRING && _GLIBCXX_USE_WEAK_REF \ && _GLIBCXX_USE_ALLOCATOR_NEW #define _GLIBCXX_TXN_SAFE transaction_safe #define _GLIBCXX_TXN_SAFE_DYN transaction_safe_dynamic #else #define _GLIBCXX_TXN_SAFE #define _GLIBCXX_TXN_SAFE_DYN #endif #if __cplusplus > 201402L // In C++17 mathematical special functions are in namespace std. # define _GLIBCXX_USE_STD_SPEC_FUNCS 1 #elif __cplusplus >= 201103L && __STDCPP_WANT_MATH_SPEC_FUNCS__ != 0 // For C++11 and C++14 they are in namespace std when requested. # define _GLIBCXX_USE_STD_SPEC_FUNCS 1 #endif // The remainder of the prewritten config is automatic; all the // user hooks are listed above. // Create a boolean flag to be used to determine if --fast-math is set. #ifdef __FAST_MATH__ # define _GLIBCXX_FAST_MATH 1 #else # define _GLIBCXX_FAST_MATH 0 #endif // This marks string literals in header files to be extracted for eventual // translation. It is primarily used for messages in thrown exceptions; see // src/functexcept.cc. We use __N because the more traditional _N is used // for something else under certain OSes (see BADNAMES). #define __N(msgid) (msgid) // For example, <windows.h> is known to #define min and max as macros... #undef min #undef max // N.B. these _GLIBCXX_USE_C99_XXX macros are defined unconditionally // so they should be tested with #if not with #ifdef. #if __cplusplus >= 201103L # ifndef _GLIBCXX_USE_C99_MATH # define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH # endif # ifndef _GLIBCXX_USE_C99_COMPLEX # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX # endif # ifndef _GLIBCXX_USE_C99_STDIO # define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO # endif # ifndef _GLIBCXX_USE_C99_STDLIB # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB # endif # ifndef _GLIBCXX_USE_C99_WCHAR # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR # endif #else # ifndef _GLIBCXX_USE_C99_MATH # define _GLIBCXX_USE_C99_MATH _GLIBCXX98_USE_C99_MATH # endif # ifndef _GLIBCXX_USE_C99_COMPLEX # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX98_USE_C99_COMPLEX # endif # ifndef _GLIBCXX_USE_C99_STDIO # define _GLIBCXX_USE_C99_STDIO _GLIBCXX98_USE_C99_STDIO # endif # ifndef _GLIBCXX_USE_C99_STDLIB # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX98_USE_C99_STDLIB # endif # ifndef _GLIBCXX_USE_C99_WCHAR # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX98_USE_C99_WCHAR # endif #endif // Unless explicitly specified, enable char8_t extensions only if the core // language char8_t feature macro is defined. #ifndef _GLIBCXX_USE_CHAR8_T # ifdef __cpp_char8_t # define _GLIBCXX_USE_CHAR8_T 1 # endif #endif #ifdef _GLIBCXX_USE_CHAR8_T # define __cpp_lib_char8_t 201907L #endif /* Define if __float128 is supported on this host. / #if defined(__FLOAT128__) \|\| defined(__SIZEOF_FLOAT128__) / For powerpc64 don't use __float128 when it's the same type as long double. / # if !(defined(_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT) && defined(__LONG_DOUBLE_IEEE128__)) # define _GLIBCXX_USE_FLOAT128 1 # endif #endif // Define if float has the IEEE binary32 format. #if __FLT_MANT_DIG__ == 24 \ && __FLT_MIN_EXP__ == -125 \ && __FLT_MAX_EXP__ == 128 # define _GLIBCXX_FLOAT_IS_IEEE_BINARY32 1 #endif // Define if double has the IEEE binary64 format. #if __DBL_MANT_DIG__ == 53 \ && __DBL_MIN_EXP__ == -1021 \ && __DBL_MAX_EXP__ == 1024 # define _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 1 #endif #ifdef __has_builtin # ifdef __is_identifier // Intel and older Clang require !__is_identifier for some built-ins: # define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B) \|\| ! __is_identifier(B) # else # define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B) # endif #endif #if _GLIBCXX_HAS_BUILTIN(__has_unique_object_representations) # define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1 #endif #if _GLIBCXX_HAS_BUILTIN(__is_aggregate) # define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1 #endif #if _GLIBCXX_HAS_BUILTIN(__builtin_is_constant_evaluated) # define _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED 1 #endif #if _GLIBCXX_HAS_BUILTIN(__is_same) # define _GLIBCXX_HAVE_BUILTIN_IS_SAME 1 #endif #if _GLIBCXX_HAS_BUILTIN(__builtin_launder) # define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1 #endif #undef _GLIBCXX_HAS_BUILTIN // PSTL configuration #if __cplusplus >= 201703L // This header is not installed for freestanding: #if __has_include(<pstl/pstl_config.h>) // Preserved here so we have some idea which version of upstream we've pulled in // #define PSTL_VERSION 9000 // For now this defaults to being based on the presence of Thread Building Blocks # ifndef _GLIBCXX_USE_TBB_PAR_BACKEND # define _GLIBCXX_USE_TBB_PAR_BACKEND __has_include(<tbb/tbb.h>) # endif // This section will need some rework when a new (default) backend type is added # if _GLIBCXX_USE_TBB_PAR_BACKEND # define _PSTL_PAR_BACKEND_TBB # else # define _PSTL_PAR_BACKEND_SERIAL # endif # define _PSTL_ASSERT(_Condition) __glibcxx_assert(_Condition) # define _PSTL_ASSERT_MSG(_Condition, _Message) __glibcxx_assert(_Condition) #include <pstl/pstl_config.h> #endif // __has_include #endif // C++17 // End of prewritten config; the settings discovered at configure time follow. / config.h. Generated from config.h.in by configure. / / config.h.in. Generated from configure.ac by autoheader. / / Define to 1 if you have the `acosf' function. / #define _GLIBCXX_HAVE_ACOSF 1 / Define to 1 if you have the `acosl' function. / #define _GLIBCXX_HAVE_ACOSL 1 / Define to 1 if you have the `aligned_alloc' function. / #define _GLIBCXX_HAVE_ALIGNED_ALLOC 1 / Define to 1 if you have the <arpa/inet.h> header file. / #define _GLIBCXX_HAVE_ARPA_INET_H 1 / Define to 1 if you have the `asinf' function. / #define _GLIBCXX_HAVE_ASINF 1 / Define to 1 if you have the `asinl' function. / #define _GLIBCXX_HAVE_ASINL 1 / Define to 1 if the target assembler supports .symver directive. / #define _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE 1 / Define to 1 if you have the `atan2f' function. / #define _GLIBCXX_HAVE_ATAN2F 1 / Define to 1 if you have the `atan2l' function. / #define _GLIBCXX_HAVE_ATAN2L 1 / Define to 1 if you have the `atanf' function. / #define _GLIBCXX_HAVE_ATANF 1 / Define to 1 if you have the `atanl' function. / #define _GLIBCXX_HAVE_ATANL 1 / Defined if shared_ptr reference counting should use atomic operations. / #define _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY 1 / Define to 1 if you have the `at_quick_exit' function. / #define _GLIBCXX_HAVE_AT_QUICK_EXIT 1 / Define to 1 if the target assembler supports thread-local storage. / / #undef _GLIBCXX_HAVE_CC_TLS / / Define to 1 if you have the `ceilf' function. / #define _GLIBCXX_HAVE_CEILF 1 / Define to 1 if you have the `ceill' function. / #define _GLIBCXX_HAVE_CEILL 1 / Define to 1 if you have the <complex.h> header file. / #define _GLIBCXX_HAVE_COMPLEX_H 1 / Define to 1 if you have the `cosf' function. / #define _GLIBCXX_HAVE_COSF 1 / Define to 1 if you have the `coshf' function. / #define _GLIBCXX_HAVE_COSHF 1 / Define to 1 if you have the `coshl' function. / #define _GLIBCXX_HAVE_COSHL 1 / Define to 1 if you have the `cosl' function. / #define _GLIBCXX_HAVE_COSL 1 / Define to 1 if you have the <dirent.h> header file. / #define _GLIBCXX_HAVE_DIRENT_H 1 / Define if dirfd is available in <dirent.h>. / #define _GLIBCXX_HAVE_DIRFD 1 / Define to 1 if you have the <dlfcn.h> header file. / #define _GLIBCXX_HAVE_DLFCN_H 1 / Define to 1 if you have the <endian.h> header file. / #define _GLIBCXX_HAVE_ENDIAN_H 1 / Define to 1 if GCC 4.6 supported std::exception_ptr for the target / #define _GLIBCXX_HAVE_EXCEPTION_PTR_SINCE_GCC46 1 / Define to 1 if you have the <execinfo.h> header file. / #define _GLIBCXX_HAVE_EXECINFO_H 1 / Define to 1 if you have the `expf' function. / #define _GLIBCXX_HAVE_EXPF 1 / Define to 1 if you have the `expl' function. / #define _GLIBCXX_HAVE_EXPL 1 / Define to 1 if you have the `fabsf' function. / #define _GLIBCXX_HAVE_FABSF 1 / Define to 1 if you have the `fabsl' function. / #define _GLIBCXX_HAVE_FABSL 1 / Define to 1 if you have the <fcntl.h> header file. / #define _GLIBCXX_HAVE_FCNTL_H 1 / Define if fdopendir is available in <dirent.h>. / #define _GLIBCXX_HAVE_FDOPENDIR 1 / Define to 1 if you have the <fenv.h> header file. / #define _GLIBCXX_HAVE_FENV_H 1 / Define to 1 if you have the `finite' function. / #define _GLIBCXX_HAVE_FINITE 1 / Define to 1 if you have the `finitef' function. / #define _GLIBCXX_HAVE_FINITEF 1 / Define to 1 if you have the `finitel' function. / #define _GLIBCXX_HAVE_FINITEL 1 / Define to 1 if you have the <float.h> header file. / #define _GLIBCXX_HAVE_FLOAT_H 1 / Define to 1 if you have the `floorf' function. / #define _GLIBCXX_HAVE_FLOORF 1 / Define to 1 if you have the `floorl' function. / #define _GLIBCXX_HAVE_FLOORL 1 / Define to 1 if you have the `fmodf' function. / #define _GLIBCXX_HAVE_FMODF 1 / Define to 1 if you have the `fmodl' function. / #define _GLIBCXX_HAVE_FMODL 1 / Define to 1 if you have the `fpclass' function. / / #undef _GLIBCXX_HAVE_FPCLASS / / Define to 1 if you have the <fp.h> header file. / / #undef _GLIBCXX_HAVE_FP_H / / Define to 1 if you have the `frexpf' function. / #define _GLIBCXX_HAVE_FREXPF 1 / Define to 1 if you have the `frexpl' function. / #define _GLIBCXX_HAVE_FREXPL 1 / Define if _Unwind_GetIPInfo is available. / #define _GLIBCXX_HAVE_GETIPINFO 1 / Define if gets is available in <stdio.h> before C++14. / #define _GLIBCXX_HAVE_GETS 1 / Define to 1 if you have the `hypot' function. / #define _GLIBCXX_HAVE_HYPOT 1 / Define to 1 if you have the `hypotf' function. / #define _GLIBCXX_HAVE_HYPOTF 1 / Define to 1 if you have the `hypotl' function. / #define _GLIBCXX_HAVE_HYPOTL 1 / Define if you have the iconv() function. / #define _GLIBCXX_HAVE_ICONV 1 / Define to 1 if you have the <ieeefp.h> header file. / / #undef _GLIBCXX_HAVE_IEEEFP_H / / Define if int64_t is available in <stdint.h>. / #define _GLIBCXX_HAVE_INT64_T 1 / Define if int64_t is a long. / / #undef _GLIBCXX_HAVE_INT64_T_LONG / / Define if int64_t is a long long. / #define _GLIBCXX_HAVE_INT64_T_LONG_LONG 1 / Define to 1 if you have the <inttypes.h> header file. / #define _GLIBCXX_HAVE_INTTYPES_H 1 / Define to 1 if you have the `isinf' function. / / #undef _GLIBCXX_HAVE_ISINF / / Define to 1 if you have the `isinff' function. / #define _GLIBCXX_HAVE_ISINFF 1 / Define to 1 if you have the `isinfl' function. / #define _GLIBCXX_HAVE_ISINFL 1 / Define to 1 if you have the `isnan' function. / / #undef _GLIBCXX_HAVE_ISNAN / / Define to 1 if you have the `isnanf' function. / #define _GLIBCXX_HAVE_ISNANF 1 / Define to 1 if you have the `isnanl' function. / #define _GLIBCXX_HAVE_ISNANL 1 / Defined if iswblank exists. / #define _GLIBCXX_HAVE_ISWBLANK 1 / Define if LC_MESSAGES is available in <locale.h>. / #define _GLIBCXX_HAVE_LC_MESSAGES 1 / Define to 1 if you have the `ldexpf' function. / #define _GLIBCXX_HAVE_LDEXPF 1 / Define to 1 if you have the `ldexpl' function. / #define _GLIBCXX_HAVE_LDEXPL 1 / Define to 1 if you have the <libintl.h> header file. / #define _GLIBCXX_HAVE_LIBINTL_H 1 / Only used in build directory testsuite_hooks.h. / #define _GLIBCXX_HAVE_LIMIT_AS 1 / Only used in build directory testsuite_hooks.h. / #define _GLIBCXX_HAVE_LIMIT_DATA 1 / Only used in build directory testsuite_hooks.h. / #define _GLIBCXX_HAVE_LIMIT_FSIZE 1 / Only used in build directory testsuite_hooks.h. / #define _GLIBCXX_HAVE_LIMIT_RSS 1 / Only used in build directory testsuite_hooks.h. / #define _GLIBCXX_HAVE_LIMIT_VMEM 0 / Define if link is available in <unistd.h>. / #define _GLIBCXX_HAVE_LINK 1 / Define if futex syscall is available. / #define _GLIBCXX_HAVE_LINUX_FUTEX 1 / Define to 1 if you have the <linux/random.h> header file. / #define _GLIBCXX_HAVE_LINUX_RANDOM_H 1 / Define to 1 if you have the <linux/types.h> header file. / #define _GLIBCXX_HAVE_LINUX_TYPES_H 1 / Define to 1 if you have the <locale.h> header file. / #define _GLIBCXX_HAVE_LOCALE_H 1 / Define to 1 if you have the `log10f' function. / #define _GLIBCXX_HAVE_LOG10F 1 / Define to 1 if you have the `log10l' function. / #define _GLIBCXX_HAVE_LOG10L 1 / Define to 1 if you have the `logf' function. / #define _GLIBCXX_HAVE_LOGF 1 / Define to 1 if you have the `logl' function. / #define _GLIBCXX_HAVE_LOGL 1 / Define to 1 if you have the <machine/endian.h> header file. / / #undef _GLIBCXX_HAVE_MACHINE_ENDIAN_H / / Define to 1 if you have the <machine/param.h> header file. / / #undef _GLIBCXX_HAVE_MACHINE_PARAM_H / / Define if mbstate_t exists in wchar.h. / #define _GLIBCXX_HAVE_MBSTATE_T 1 / Define to 1 if you have the `memalign' function. / #define _GLIBCXX_HAVE_MEMALIGN 1 / Define to 1 if you have the <memory.h> header file. / #define _GLIBCXX_HAVE_MEMORY_H 1 / Define to 1 if you have the `modf' function. / #define _GLIBCXX_HAVE_MODF 1 / Define to 1 if you have the `modff' function. / #define _GLIBCXX_HAVE_MODFF 1 / Define to 1 if you have the `modfl' function. / #define _GLIBCXX_HAVE_MODFL 1 / Define to 1 if you have the <nan.h> header file. / / #undef _GLIBCXX_HAVE_NAN_H / / Define to 1 if you have the <netdb.h> header file. / #define _GLIBCXX_HAVE_NETDB_H 1 / Define to 1 if you have the <netinet/in.h> header file. / #define _GLIBCXX_HAVE_NETINET_IN_H 1 / Define to 1 if you have the <netinet/tcp.h> header file. / #define _GLIBCXX_HAVE_NETINET_TCP_H 1 / Define if <math.h> defines obsolete isinf function. / / #undef _GLIBCXX_HAVE_OBSOLETE_ISINF / / Define if <math.h> defines obsolete isnan function. / / #undef _GLIBCXX_HAVE_OBSOLETE_ISNAN / / Define if openat is available in <fcntl.h>. / #define _GLIBCXX_HAVE_OPENAT 1 / Define if poll is available in <poll.h>. / #define _GLIBCXX_HAVE_POLL 1 / Define to 1 if you have the <poll.h> header file. / #define _GLIBCXX_HAVE_POLL_H 1 / Define to 1 if you have the `posix_memalign' function. / #define _GLIBCXX_HAVE_POSIX_MEMALIGN 1 / Define to 1 if POSIX Semaphores with sem_timedwait are available in <semaphore.h>. / #define _GLIBCXX_HAVE_POSIX_SEMAPHORE 1 / Define to 1 if you have the `powf' function. / #define _GLIBCXX_HAVE_POWF 1 / Define to 1 if you have the `powl' function. / #define _GLIBCXX_HAVE_POWL 1 / Define to 1 if you have the `qfpclass' function. / / #undef _GLIBCXX_HAVE_QFPCLASS / / Define to 1 if you have the `quick_exit' function. / #define _GLIBCXX_HAVE_QUICK_EXIT 1 / Define if readlink is available in <unistd.h>. / #define _GLIBCXX_HAVE_READLINK 1 / Define to 1 if you have the `secure_getenv' function. / #define _GLIBCXX_HAVE_SECURE_GETENV 1 / Define to 1 if you have the `setenv' function. / #define _GLIBCXX_HAVE_SETENV 1 / Define to 1 if you have the `sincos' function. / #define _GLIBCXX_HAVE_SINCOS 1 / Define to 1 if you have the `sincosf' function. / #define _GLIBCXX_HAVE_SINCOSF 1 / Define to 1 if you have the `sincosl' function. / #define _GLIBCXX_HAVE_SINCOSL 1 / Define to 1 if you have the `sinf' function. / #define _GLIBCXX_HAVE_SINF 1 / Define to 1 if you have the `sinhf' function. / #define _GLIBCXX_HAVE_SINHF 1 / Define to 1 if you have the `sinhl' function. / #define _GLIBCXX_HAVE_SINHL 1 / Define to 1 if you have the `sinl' function. / #define _GLIBCXX_HAVE_SINL 1 / Defined if sleep exists. / / #undef _GLIBCXX_HAVE_SLEEP / / Define to 1 if you have the `sockatmark' function. / #define _GLIBCXX_HAVE_SOCKATMARK 1 / Define to 1 if you have the `sqrtf' function. / #define _GLIBCXX_HAVE_SQRTF 1 / Define to 1 if you have the `sqrtl' function. / #define _GLIBCXX_HAVE_SQRTL 1 / Define to 1 if you have the <stdalign.h> header file. / #define _GLIBCXX_HAVE_STDALIGN_H 1 / Define to 1 if you have the <stdbool.h> header file. / #define _GLIBCXX_HAVE_STDBOOL_H 1 / Define to 1 if you have the <stdint.h> header file. / #define _GLIBCXX_HAVE_STDINT_H 1 / Define to 1 if you have the <stdlib.h> header file. / #define _GLIBCXX_HAVE_STDLIB_H 1 / Define if strerror_l is available in <string.h>. / #define _GLIBCXX_HAVE_STRERROR_L 1 / Define if strerror_r is available in <string.h>. / #define _GLIBCXX_HAVE_STRERROR_R 1 / Define to 1 if you have the <strings.h> header file. / #define _GLIBCXX_HAVE_STRINGS_H 1 / Define to 1 if you have the <string.h> header file. / #define _GLIBCXX_HAVE_STRING_H 1 / Define to 1 if you have the `strtof' function. / #define _GLIBCXX_HAVE_STRTOF 1 / Define to 1 if you have the `strtold' function. / #define _GLIBCXX_HAVE_STRTOLD 1 / Define to 1 if `d_type' is a member of `struct dirent'. / #define _GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPE 1 / Define if strxfrm_l is available in <string.h>. / #define _GLIBCXX_HAVE_STRXFRM_L 1 / Define if symlink is available in <unistd.h>. / #define _GLIBCXX_HAVE_SYMLINK 1 / Define to 1 if the target runtime linker supports binding the same symbol to different versions. / #define _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT 1 / Define to 1 if you have the <sys/filio.h> header file. / / #undef _GLIBCXX_HAVE_SYS_FILIO_H / / Define to 1 if you have the <sys/ioctl.h> header file. / #define _GLIBCXX_HAVE_SYS_IOCTL_H 1 / Define to 1 if you have the <sys/ipc.h> header file. / #define _GLIBCXX_HAVE_SYS_IPC_H 1 / Define to 1 if you have the <sys/isa_defs.h> header file. / / #undef _GLIBCXX_HAVE_SYS_ISA_DEFS_H / / Define to 1 if you have the <sys/machine.h> header file. / / #undef _GLIBCXX_HAVE_SYS_MACHINE_H / / Define to 1 if you have the <sys/param.h> header file. / #define _GLIBCXX_HAVE_SYS_PARAM_H 1 / Define to 1 if you have the <sys/resource.h> header file. / #define _GLIBCXX_HAVE_SYS_RESOURCE_H 1 / Define to 1 if you have a suitable <sys/sdt.h> header file / #define _GLIBCXX_HAVE_SYS_SDT_H 1 / Define to 1 if you have the <sys/sem.h> header file. / #define _GLIBCXX_HAVE_SYS_SEM_H 1 / Define to 1 if you have the <sys/socket.h> header file. / #define _GLIBCXX_HAVE_SYS_SOCKET_H 1 / Define to 1 if you have the <sys/statvfs.h> header file. / #define _GLIBCXX_HAVE_SYS_STATVFS_H 1 / Define to 1 if you have the <sys/stat.h> header file. / #define _GLIBCXX_HAVE_SYS_STAT_H 1 / Define to 1 if you have the <sys/sysinfo.h> header file. / #define _GLIBCXX_HAVE_SYS_SYSINFO_H 1 / Define to 1 if you have the <sys/time.h> header file. / #define _GLIBCXX_HAVE_SYS_TIME_H 1 / Define to 1 if you have the <sys/types.h> header file. / #define _GLIBCXX_HAVE_SYS_TYPES_H 1 / Define to 1 if you have the <sys/uio.h> header file. / #define _GLIBCXX_HAVE_SYS_UIO_H 1 / Define if S_IFREG is available in <sys/stat.h>. / / #undef _GLIBCXX_HAVE_S_IFREG / / Define if S_ISREG is available in <sys/stat.h>. / #define _GLIBCXX_HAVE_S_ISREG 1 / Define to 1 if you have the `tanf' function. / #define _GLIBCXX_HAVE_TANF 1 / Define to 1 if you have the `tanhf' function. / #define _GLIBCXX_HAVE_TANHF 1 / Define to 1 if you have the `tanhl' function. / #define _GLIBCXX_HAVE_TANHL 1 / Define to 1 if you have the `tanl' function. / #define _GLIBCXX_HAVE_TANL 1 / Define to 1 if you have the <tgmath.h> header file. / #define _GLIBCXX_HAVE_TGMATH_H 1 / Define to 1 if you have the `timespec_get' function. / #define _GLIBCXX_HAVE_TIMESPEC_GET 1 / Define to 1 if the target supports thread-local storage. / #define _GLIBCXX_HAVE_TLS 1 / Define if truncate is available in <unistd.h>. / #define _GLIBCXX_HAVE_TRUNCATE 1 / Define to 1 if you have the <uchar.h> header file. / #define _GLIBCXX_HAVE_UCHAR_H 1 / Define to 1 if you have the <unistd.h> header file. / #define _GLIBCXX_HAVE_UNISTD_H 1 / Define if unlinkat is available in <fcntl.h>. / #define _GLIBCXX_HAVE_UNLINKAT 1 / Define to 1 if you have the `uselocale' function. / #define _GLIBCXX_HAVE_USELOCALE 1 / Defined if usleep exists. / / #undef _GLIBCXX_HAVE_USLEEP / / Define to 1 if you have the <utime.h> header file. / #define _GLIBCXX_HAVE_UTIME_H 1 / Defined if vfwscanf exists. / #define _GLIBCXX_HAVE_VFWSCANF 1 / Defined if vswscanf exists. / #define _GLIBCXX_HAVE_VSWSCANF 1 / Defined if vwscanf exists. / #define _GLIBCXX_HAVE_VWSCANF 1 / Define to 1 if you have the <wchar.h> header file. / #define _GLIBCXX_HAVE_WCHAR_H 1 / Defined if wcstof exists. / #define _GLIBCXX_HAVE_WCSTOF 1 / Define to 1 if you have the <wctype.h> header file. / #define _GLIBCXX_HAVE_WCTYPE_H 1 / Defined if Sleep exists. / / #undef _GLIBCXX_HAVE_WIN32_SLEEP / / Define if writev is available in <sys/uio.h>. / #define _GLIBCXX_HAVE_WRITEV 1 / Define to 1 if you have the <xlocale.h> header file. / / #undef _GLIBCXX_HAVE_XLOCALE_H / / Define to 1 if you have the `_acosf' function. / / #undef _GLIBCXX_HAVE__ACOSF / / Define to 1 if you have the `_acosl' function. / / #undef _GLIBCXX_HAVE__ACOSL / / Define to 1 if you have the `_aligned_malloc' function. / / #undef _GLIBCXX_HAVE__ALIGNED_MALLOC / / Define to 1 if you have the `_asinf' function. / / #undef _GLIBCXX_HAVE__ASINF / / Define to 1 if you have the `_asinl' function. / / #undef _GLIBCXX_HAVE__ASINL / / Define to 1 if you have the `_atan2f' function. / / #undef _GLIBCXX_HAVE__ATAN2F / / Define to 1 if you have the `_atan2l' function. / / #undef _GLIBCXX_HAVE__ATAN2L / / Define to 1 if you have the `_atanf' function. / / #undef _GLIBCXX_HAVE__ATANF / / Define to 1 if you have the `_atanl' function. / / #undef _GLIBCXX_HAVE__ATANL / / Define to 1 if you have the `_ceilf' function. / / #undef _GLIBCXX_HAVE__CEILF / / Define to 1 if you have the `_ceill' function. / / #undef _GLIBCXX_HAVE__CEILL / / Define to 1 if you have the `_cosf' function. / / #undef _GLIBCXX_HAVE__COSF / / Define to 1 if you have the `_coshf' function. / / #undef _GLIBCXX_HAVE__COSHF / / Define to 1 if you have the `_coshl' function. / / #undef _GLIBCXX_HAVE__COSHL / / Define to 1 if you have the `_cosl' function. / / #undef _GLIBCXX_HAVE__COSL / / Define to 1 if you have the `_expf' function. / / #undef _GLIBCXX_HAVE__EXPF / / Define to 1 if you have the `_expl' function. / / #undef _GLIBCXX_HAVE__EXPL / / Define to 1 if you have the `_fabsf' function. / / #undef _GLIBCXX_HAVE__FABSF / / Define to 1 if you have the `_fabsl' function. / / #undef _GLIBCXX_HAVE__FABSL / / Define to 1 if you have the `_finite' function. / / #undef _GLIBCXX_HAVE__FINITE / / Define to 1 if you have the `_finitef' function. / / #undef _GLIBCXX_HAVE__FINITEF / / Define to 1 if you have the `_finitel' function. / / #undef _GLIBCXX_HAVE__FINITEL / / Define to 1 if you have the `_floorf' function. / / #undef _GLIBCXX_HAVE__FLOORF / / Define to 1 if you have the `_floorl' function. / / #undef _GLIBCXX_HAVE__FLOORL / / Define to 1 if you have the `_fmodf' function. / / #undef _GLIBCXX_HAVE__FMODF / / Define to 1 if you have the `_fmodl' function. / / #undef _GLIBCXX_HAVE__FMODL / / Define to 1 if you have the `_fpclass' function. / / #undef _GLIBCXX_HAVE__FPCLASS / / Define to 1 if you have the `_frexpf' function. / / #undef _GLIBCXX_HAVE__FREXPF / / Define to 1 if you have the `_frexpl' function. / / #undef _GLIBCXX_HAVE__FREXPL / / Define to 1 if you have the `_hypot' function. / / #undef _GLIBCXX_HAVE__HYPOT / / Define to 1 if you have the `_hypotf' function. / / #undef _GLIBCXX_HAVE__HYPOTF / / Define to 1 if you have the `_hypotl' function. / / #undef _GLIBCXX_HAVE__HYPOTL / / Define to 1 if you have the `_isinf' function. / / #undef _GLIBCXX_HAVE__ISINF / / Define to 1 if you have the `_isinff' function. / / #undef _GLIBCXX_HAVE__ISINFF / / Define to 1 if you have the `_isinfl' function. / / #undef _GLIBCXX_HAVE__ISINFL / / Define to 1 if you have the `_isnan' function. / / #undef _GLIBCXX_HAVE__ISNAN / / Define to 1 if you have the `_isnanf' function. / / #undef _GLIBCXX_HAVE__ISNANF / / Define to 1 if you have the `_isnanl' function. / / #undef _GLIBCXX_HAVE__ISNANL / / Define to 1 if you have the `_ldexpf' function. / / #undef _GLIBCXX_HAVE__LDEXPF / / Define to 1 if you have the `_ldexpl' function. / / #undef _GLIBCXX_HAVE__LDEXPL / / Define to 1 if you have the `_log10f' function. / / #undef _GLIBCXX_HAVE__LOG10F / / Define to 1 if you have the `_log10l' function. / / #undef _GLIBCXX_HAVE__LOG10L / / Define to 1 if you have the `_logf' function. / / #undef _GLIBCXX_HAVE__LOGF / / Define to 1 if you have the `_logl' function. / / #undef _GLIBCXX_HAVE__LOGL / / Define to 1 if you have the `_modf' function. / / #undef _GLIBCXX_HAVE__MODF / / Define to 1 if you have the `_modff' function. / / #undef _GLIBCXX_HAVE__MODFF / / Define to 1 if you have the `_modfl' function. / / #undef _GLIBCXX_HAVE__MODFL / / Define to 1 if you have the `_powf' function. / / #undef _GLIBCXX_HAVE__POWF / / Define to 1 if you have the `_powl' function. / / #undef _GLIBCXX_HAVE__POWL / / Define to 1 if you have the `_qfpclass' function. / / #undef _GLIBCXX_HAVE__QFPCLASS / / Define to 1 if you have the `_sincos' function. / / #undef _GLIBCXX_HAVE__SINCOS / / Define to 1 if you have the `_sincosf' function. / / #undef _GLIBCXX_HAVE__SINCOSF / / Define to 1 if you have the `_sincosl' function. / / #undef _GLIBCXX_HAVE__SINCOSL / / Define to 1 if you have the `_sinf' function. / / #undef _GLIBCXX_HAVE__SINF / / Define to 1 if you have the `_sinhf' function. / / #undef _GLIBCXX_HAVE__SINHF / / Define to 1 if you have the `_sinhl' function. / / #undef _GLIBCXX_HAVE__SINHL / / Define to 1 if you have the `_sinl' function. / / #undef _GLIBCXX_HAVE__SINL / / Define to 1 if you have the `_sqrtf' function. / / #undef _GLIBCXX_HAVE__SQRTF / / Define to 1 if you have the `_sqrtl' function. / / #undef _GLIBCXX_HAVE__SQRTL / / Define to 1 if you have the `_tanf' function. / / #undef _GLIBCXX_HAVE__TANF / / Define to 1 if you have the `_tanhf' function. / / #undef _GLIBCXX_HAVE__TANHF / / Define to 1 if you have the `_tanhl' function. / / #undef _GLIBCXX_HAVE__TANHL / / Define to 1 if you have the `_tanl' function. / / #undef _GLIBCXX_HAVE__TANL / / Define to 1 if you have the `_wfopen' function. / / #undef _GLIBCXX_HAVE__WFOPEN / / Define to 1 if you have the `__cxa_thread_atexit' function. / / #undef _GLIBCXX_HAVE___CXA_THREAD_ATEXIT / / Define to 1 if you have the `__cxa_thread_atexit_impl' function. / #define _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL 1 / Define as const if the declaration of iconv() needs const. / #define _GLIBCXX_ICONV_CONST / Define to the sub-directory in which libtool stores uninstalled libraries. / #define _GLIBCXX_LT_OBJDIR ".libs/" / Name of package / / #undef _GLIBCXX_PACKAGE / / Define to the address where bug reports for this package should be sent. / #define _GLIBCXX_PACKAGE_BUGREPORT "" / Define to the full name of this package. / #define _GLIBCXX_PACKAGE_NAME "package-unused" / Define to the full name and version of this package. / #define _GLIBCXX_PACKAGE_STRING "package-unused version-unused" / Define to the one symbol short name of this package. / #define _GLIBCXX_PACKAGE_TARNAME "libstdc++" / Define to the home page for this package. / #define _GLIBCXX_PACKAGE_URL "" / Define to the version of this package. / #define _GLIBCXX_PACKAGE__GLIBCXX_VERSION "version-unused" / The size of `char', as computed by sizeof. / / #undef SIZEOF_CHAR / / The size of `int', as computed by sizeof. / / #undef SIZEOF_INT / / The size of `long', as computed by sizeof. / / #undef SIZEOF_LONG / / The size of `short', as computed by sizeof. / / #undef SIZEOF_SHORT / / The size of `void ', as computed by sizeof. / /* #undef SIZEOF_VOID_P / / Define to 1 if you have the ANSI C header files. / #define _GLIBCXX_STDC_HEADERS 1 / Version number of package / / #undef _GLIBCXX_VERSION / / Enable large inode numbers on Mac OS X 10.5. / #ifndef _GLIBCXX_DARWIN_USE_64_BIT_INODE # define _GLIBCXX_DARWIN_USE_64_BIT_INODE 1 #endif / Number of bits in a file offset, on hosts where this is settable. / #define _GLIBCXX_FILE_OFFSET_BITS 64 / Define if C99 functions in <complex.h> should be used in <complex> for C++11. Using compiler builtins for these functions requires corresponding C99 library functions to be present. / #define _GLIBCXX11_USE_C99_COMPLEX 1 / Define if C99 functions or macros in <math.h> should be imported in <cmath> in namespace std for C++11. / #define _GLIBCXX11_USE_C99_MATH 1 / Define if C99 functions or macros in <stdio.h> should be imported in <cstdio> in namespace std for C++11. / #define _GLIBCXX11_USE_C99_STDIO 1 / Define if C99 functions or macros in <stdlib.h> should be imported in <cstdlib> in namespace std for C++11. / #define _GLIBCXX11_USE_C99_STDLIB 1 / Define if C99 functions or macros in <wchar.h> should be imported in <cwchar> in namespace std for C++11. / #define _GLIBCXX11_USE_C99_WCHAR 1 / Define if C99 functions in <complex.h> should be used in <complex> for C++98. Using compiler builtins for these functions requires corresponding C99 library functions to be present. / #define _GLIBCXX98_USE_C99_COMPLEX 1 / Define if C99 functions or macros in <math.h> should be imported in <cmath> in namespace std for C++98. / #define _GLIBCXX98_USE_C99_MATH 1 / Define if C99 functions or macros in <stdio.h> should be imported in <cstdio> in namespace std for C++98. / #define _GLIBCXX98_USE_C99_STDIO 1 / Define if C99 functions or macros in <stdlib.h> should be imported in <cstdlib> in namespace std for C++98. / #define _GLIBCXX98_USE_C99_STDLIB 1 / Define if C99 functions or macros in <wchar.h> should be imported in <cwchar> in namespace std for C++98. / #define _GLIBCXX98_USE_C99_WCHAR 1 / Define if the compiler supports C++11 atomics. / #define _GLIBCXX_ATOMIC_BUILTINS 1 / Define to use concept checking code from the boost libraries. / / #undef _GLIBCXX_CONCEPT_CHECKS / / Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults / #define _GLIBCXX_FULLY_DYNAMIC_STRING 0 / Define if gthreads library is available. / #define _GLIBCXX_HAS_GTHREADS 1 / Define to 1 if a full hosted library is built, or 0 if freestanding. / #define _GLIBCXX_HOSTED 1 / Define if compatibility should be provided for alternative 128-bit long double formats. / / Define if compatibility should be provided for -mlong-double-64. / / Define to the letter to which size_t is mangled. / #define _GLIBCXX_MANGLE_SIZE_T j / Define if C99 llrint and llround functions are missing from <math.h>. / / #undef _GLIBCXX_NO_C99_ROUNDING_FUNCS / / Defined if no way to sleep is available. / / #undef _GLIBCXX_NO_SLEEP / / Define if ptrdiff_t is int. / #define _GLIBCXX_PTRDIFF_T_IS_INT 1 / Define if using setrlimit to set resource limits during "make check" / #define _GLIBCXX_RES_LIMITS 1 / Define if size_t is unsigned int. / #define _GLIBCXX_SIZE_T_IS_UINT 1 / Define to the value of the EOF integer constant. / #define _GLIBCXX_STDIO_EOF -1 / Define to the value of the SEEK_CUR integer constant. / #define _GLIBCXX_STDIO_SEEK_CUR 1 / Define to the value of the SEEK_END integer constant. / #define _GLIBCXX_STDIO_SEEK_END 2 / Define to use symbol versioning in the shared library. / #define _GLIBCXX_SYMVER 1 / Define to use darwin versioning in the shared library. / / #undef _GLIBCXX_SYMVER_DARWIN / / Define to use GNU versioning in the shared library. / #define _GLIBCXX_SYMVER_GNU 1 / Define to use GNU namespace versioning in the shared library. / / #undef _GLIBCXX_SYMVER_GNU_NAMESPACE / / Define to use Sun versioning in the shared library. / / #undef _GLIBCXX_SYMVER_SUN / / Define if C11 functions in <uchar.h> should be imported into namespace std in <cuchar>. / #define _GLIBCXX_USE_C11_UCHAR_CXX11 1 / Define if C99 functions or macros from <wchar.h>, <math.h>, <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed. / #define _GLIBCXX_USE_C99 1 / Define if C99 functions in <complex.h> should be used in <tr1/complex>. Using compiler builtins for these functions requires corresponding C99 library functions to be present. / #define _GLIBCXX_USE_C99_COMPLEX_TR1 1 / Define if C99 functions in <ctype.h> should be imported in <tr1/cctype> in namespace std::tr1. / #define _GLIBCXX_USE_C99_CTYPE_TR1 1 / Define if C99 functions in <fenv.h> should be imported in <tr1/cfenv> in namespace std::tr1. / #define _GLIBCXX_USE_C99_FENV_TR1 1 / Define if C99 functions in <inttypes.h> should be imported in <tr1/cinttypes> in namespace std::tr1. / #define _GLIBCXX_USE_C99_INTTYPES_TR1 1 / Define if wchar_t C99 functions in <inttypes.h> should be imported in <tr1/cinttypes> in namespace std::tr1. / #define _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 1 / Define if C99 functions or macros in <math.h> should be imported in <tr1/cmath> in namespace std::tr1. / #define _GLIBCXX_USE_C99_MATH_TR1 1 / Define if C99 types in <stdint.h> should be imported in <tr1/cstdint> in namespace std::tr1. / #define _GLIBCXX_USE_C99_STDINT_TR1 1 / Defined if clock_gettime syscall has monotonic and realtime clock support. / / #undef _GLIBCXX_USE_CLOCK_GETTIME_SYSCALL / / Defined if clock_gettime has monotonic clock support. / #define _GLIBCXX_USE_CLOCK_MONOTONIC 1 / Defined if clock_gettime has realtime clock support. / #define _GLIBCXX_USE_CLOCK_REALTIME 1 / Define if ISO/IEC TR 24733 decimal floating point types are supported on this host. / #define _GLIBCXX_USE_DECIMAL_FLOAT 1 / Define if /dev/random and /dev/urandom are available for std::random_device. / #define _GLIBCXX_USE_DEV_RANDOM 1 / Define if fchmod is available in <sys/stat.h>. / #define _GLIBCXX_USE_FCHMOD 1 / Define if fchmodat is available in <sys/stat.h>. / #define _GLIBCXX_USE_FCHMODAT 1 / Defined if gettimeofday is available. / #define _GLIBCXX_USE_GETTIMEOFDAY 1 / Define if get_nprocs is available in <sys/sysinfo.h>. / #define _GLIBCXX_USE_GET_NPROCS 1 / Define if __int128 is supported on this host. / / #undef _GLIBCXX_USE_INT128 / / Define if LFS support is available. / #define _GLIBCXX_USE_LFS 1 / Define if code specialized for long long should be used. / #define _GLIBCXX_USE_LONG_LONG 1 / Define if lstat is available in <sys/stat.h>. / #define _GLIBCXX_USE_LSTAT 1 / Defined if nanosleep is available. / #define _GLIBCXX_USE_NANOSLEEP 1 / Define if NLS translations are to be used. / #define _GLIBCXX_USE_NLS 1 / Define if pthreads_num_processors_np is available in <pthread.h>. / / #undef _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP / / Define if pthread_cond_clockwait is available in <pthread.h>. / #define _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT 1 / Define if pthread_mutex_clocklock is available in <pthread.h>. / #define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK 1 / Define if pthread_rwlock_clockrdlock and pthread_rwlock_clockwrlock are available in <pthread.h>. / #define _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK 1 / Define if POSIX read/write locks are available in <gthr.h>. / #define _GLIBCXX_USE_PTHREAD_RWLOCK_T 1 / Define if /dev/random and /dev/urandom are available for the random_device of TR1 (Chapter 5.1). / #define _GLIBCXX_USE_RANDOM_TR1 1 / Define if usable realpath is available in <stdlib.h>. / #define _GLIBCXX_USE_REALPATH 1 / Defined if sched_yield is available. / #define _GLIBCXX_USE_SCHED_YIELD 1 / Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>. / #define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1 / Define if _SC_NPROC_ONLN is available in <unistd.h>. / / #undef _GLIBCXX_USE_SC_NPROC_ONLN / / Define if sendfile is available in <sys/sendfile.h>. / #define _GLIBCXX_USE_SENDFILE 1 / Define to restrict std::__basic_file<> to stdio APIs. / / #undef _GLIBCXX_USE_STDIO_PURE / / Define if struct stat has timespec members. / #define _GLIBCXX_USE_ST_MTIM 1 / Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>. / / #undef _GLIBCXX_USE_SYSCTL_HW_NCPU / / Define if obsolescent tmpnam is available in <stdio.h>. / #define _GLIBCXX_USE_TMPNAM 1 / Define if utime is available in <utime.h>. / #define _GLIBCXX_USE_UTIME 1 / Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>. / #define _GLIBCXX_USE_UTIMENSAT 1 / Define if code specialized for wchar_t should be used. / #define _GLIBCXX_USE_WCHAR_T 1 / Define to 1 if a verbose library is built, or 0 otherwise. / #define _GLIBCXX_VERBOSE 1 / Defined if as can handle rdrand. / #define _GLIBCXX_X86_RDRAND 1 / Defined if as can handle rdseed. / #define _GLIBCXX_X86_RDSEED 1 / Define to 1 if mutex_timedlock is available. / #define _GTHREAD_USE_MUTEX_TIMEDLOCK 1 / Define for large files, on AIX-style hosts. / / #undef _GLIBCXX_LARGE_FILES / / Define if all C++11 floating point overloads are available in <math.h>. / #if __cplusplus >= 201103L / #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP / #endif / Define if all C++11 integral type overloads are available in <math.h>. / #if __cplusplus >= 201103L / #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT */ #endif #if defined (_GLIBCXX_HAVE__ACOSF) && ! defined (_GLIBCXX_HAVE_ACOSF) # define _GLIBCXX_HAVE_ACOSF 1 # define acosf _acosf #endif #if defined (_GLIBCXX_HAVE__ACOSL) && ! defined (_GLIBCXX_HAVE_ACOSL) # define _GLIBCXX_HAVE_ACOSL 1 # define acosl _acosl #endif #if defined (_GLIBCXX_HAVE__ASINF) && ! defined (_GLIBCXX_HAVE_ASINF) # define _GLIBCXX_HAVE_ASINF 1 # define asinf _asinf #endif #if defined (_GLIBCXX_HAVE__ASINL) && ! defined (_GLIBCXX_HAVE_ASINL) # define _GLIBCXX_HAVE_ASINL 1 # define asinl _asinl #endif #if defined (_GLIBCXX_HAVE__ATAN2F) && ! defined (_GLIBCXX_HAVE_ATAN2F) # define _GLIBCXX_HAVE_ATAN2F 1 # define atan2f _atan2f #endif #if defined (_GLIBCXX_HAVE__ATAN2L) && ! defined (_GLIBCXX_HAVE_ATAN2L) # define _GLIBCXX_HAVE_ATAN2L 1 # define atan2l _atan2l #endif #if defined (_GLIBCXX_HAVE__ATANF) && ! defined (_GLIBCXX_HAVE_ATANF) # define _GLIBCXX_HAVE_ATANF 1 # define atanf _atanf #endif #if defined (_GLIBCXX_HAVE__ATANL) && ! defined (_GLIBCXX_HAVE_ATANL) # define _GLIBCXX_HAVE_ATANL 1 # define atanl _atanl #endif #if defined (_GLIBCXX_HAVE__CEILF) && ! defined (_GLIBCXX_HAVE_CEILF) # define _GLIBCXX_HAVE_CEILF 1 # define ceilf _ceilf #endif #if defined (_GLIBCXX_HAVE__CEILL) && ! defined (_GLIBCXX_HAVE_CEILL) # define _GLIBCXX_HAVE_CEILL 1 # define ceill _ceill #endif #if defined (_GLIBCXX_HAVE__COSF) && ! defined (_GLIBCXX_HAVE_COSF) # define _GLIBCXX_HAVE_COSF 1 # define cosf _cosf #endif #if defined (_GLIBCXX_HAVE__COSHF) && ! defined (_GLIBCXX_HAVE_COSHF) # define _GLIBCXX_HAVE_COSHF 1 # define coshf _coshf #endif #if defined (_GLIBCXX_HAVE__COSHL) && ! defined (_GLIBCXX_HAVE_COSHL) # define _GLIBCXX_HAVE_COSHL 1 # define coshl _coshl #endif #if defined (_GLIBCXX_HAVE__COSL) && ! defined (_GLIBCXX_HAVE_COSL) # define _GLIBCXX_HAVE_COSL 1 # define cosl _cosl #endif #if defined (_GLIBCXX_HAVE__EXPF) && ! defined (_GLIBCXX_HAVE_EXPF) # define _GLIBCXX_HAVE_EXPF 1 # define expf _expf #endif #if defined (_GLIBCXX_HAVE__EXPL) && ! defined (_GLIBCXX_HAVE_EXPL) # define _GLIBCXX_HAVE_EXPL 1 # define expl _expl #endif #if defined (_GLIBCXX_HAVE__FABSF) && ! defined (_GLIBCXX_HAVE_FABSF) # define _GLIBCXX_HAVE_FABSF 1 # define fabsf _fabsf #endif #if defined (_GLIBCXX_HAVE__FABSL) && ! defined (_GLIBCXX_HAVE_FABSL) # define _GLIBCXX_HAVE_FABSL 1 # define fabsl _fabsl #endif #if defined (_GLIBCXX_HAVE__FINITE) && ! defined (_GLIBCXX_HAVE_FINITE) # define _GLIBCXX_HAVE_FINITE 1 # define finite _finite #endif #if defined (_GLIBCXX_HAVE__FINITEF) && ! defined (_GLIBCXX_HAVE_FINITEF) # define _GLIBCXX_HAVE_FINITEF 1 # define finitef _finitef #endif #if defined (_GLIBCXX_HAVE__FINITEL) && ! defined (_GLIBCXX_HAVE_FINITEL) # define _GLIBCXX_HAVE_FINITEL 1 # define finitel _finitel #endif #if defined (_GLIBCXX_HAVE__FLOORF) && ! defined (_GLIBCXX_HAVE_FLOORF) # define _GLIBCXX_HAVE_FLOORF 1 # define floorf _floorf #endif #if defined (_GLIBCXX_HAVE__FLOORL) && ! defined (_GLIBCXX_HAVE_FLOORL) # define _GLIBCXX_HAVE_FLOORL 1 # define floorl _floorl #endif #if defined (_GLIBCXX_HAVE__FMODF) && ! defined (_GLIBCXX_HAVE_FMODF) # define _GLIBCXX_HAVE_FMODF 1 # define fmodf _fmodf #endif #if defined (_GLIBCXX_HAVE__FMODL) && ! defined (_GLIBCXX_HAVE_FMODL) # define _GLIBCXX_HAVE_FMODL 1 # define fmodl _fmodl #endif #if defined (_GLIBCXX_HAVE__FPCLASS) && ! defined (_GLIBCXX_HAVE_FPCLASS) # define _GLIBCXX_HAVE_FPCLASS 1 # define fpclass _fpclass #endif #if defined (_GLIBCXX_HAVE__FREXPF) && ! defined (_GLIBCXX_HAVE_FREXPF) # define _GLIBCXX_HAVE_FREXPF 1 # define frexpf _frexpf #endif #if defined (_GLIBCXX_HAVE__FREXPL) && ! defined (_GLIBCXX_HAVE_FREXPL) # define _GLIBCXX_HAVE_FREXPL 1 # define frexpl _frexpl #endif #if defined (_GLIBCXX_HAVE__HYPOT) && ! defined (_GLIBCXX_HAVE_HYPOT) # define _GLIBCXX_HAVE_HYPOT 1 # define hypot _hypot #endif #if defined (_GLIBCXX_HAVE__HYPOTF) && ! defined (_GLIBCXX_HAVE_HYPOTF) # define _GLIBCXX_HAVE_HYPOTF 1 # define hypotf _hypotf #endif #if defined (_GLIBCXX_HAVE__HYPOTL) && ! defined (_GLIBCXX_HAVE_HYPOTL) # define _GLIBCXX_HAVE_HYPOTL 1 # define hypotl _hypotl #endif #if defined (_GLIBCXX_HAVE__ISINF) && ! defined (_GLIBCXX_HAVE_ISINF) # define _GLIBCXX_HAVE_ISINF 1 # define isinf _isinf #endif #if defined (_GLIBCXX_HAVE__ISINFF) && ! defined (_GLIBCXX_HAVE_ISINFF) # define _GLIBCXX_HAVE_ISINFF 1 # define isinff _isinff #endif #if defined (_GLIBCXX_HAVE__ISINFL) && ! defined (_GLIBCXX_HAVE_ISINFL) # define _GLIBCXX_HAVE_ISINFL 1 # define isinfl _isinfl #endif #if defined (_GLIBCXX_HAVE__ISNAN) && ! defined (_GLIBCXX_HAVE_ISNAN) # define _GLIBCXX_HAVE_ISNAN 1 # define isnan _isnan #endif #if defined (_GLIBCXX_HAVE__ISNANF) && ! defined (_GLIBCXX_HAVE_ISNANF) # define _GLIBCXX_HAVE_ISNANF 1 # define isnanf _isnanf #endif #if defined (_GLIBCXX_HAVE__ISNANL) && ! defined (_GLIBCXX_HAVE_ISNANL) # define _GLIBCXX_HAVE_ISNANL 1 # define isnanl _isnanl #endif #if defined (_GLIBCXX_HAVE__LDEXPF) && ! defined (_GLIBCXX_HAVE_LDEXPF) # define _GLIBCXX_HAVE_LDEXPF 1 # define ldexpf _ldexpf #endif #if defined (_GLIBCXX_HAVE__LDEXPL) && ! defined (_GLIBCXX_HAVE_LDEXPL) # define _GLIBCXX_HAVE_LDEXPL 1 # define ldexpl _ldexpl #endif #if defined (_GLIBCXX_HAVE__LOG10F) && ! defined (_GLIBCXX_HAVE_LOG10F) # define _GLIBCXX_HAVE_LOG10F 1 # define log10f _log10f #endif #if defined (_GLIBCXX_HAVE__LOG10L) && ! defined (_GLIBCXX_HAVE_LOG10L) # define _GLIBCXX_HAVE_LOG10L 1 # define log10l _log10l #endif #if defined (_GLIBCXX_HAVE__LOGF) && ! defined (_GLIBCXX_HAVE_LOGF) # define _GLIBCXX_HAVE_LOGF 1 # define logf _logf #endif #if defined (_GLIBCXX_HAVE__LOGL) && ! defined (_GLIBCXX_HAVE_LOGL) # define _GLIBCXX_HAVE_LOGL 1 # define logl _logl #endif #if defined (_GLIBCXX_HAVE__MODF) && ! defined (_GLIBCXX_HAVE_MODF) # define _GLIBCXX_HAVE_MODF 1 # define modf _modf #endif #if defined (_GLIBCXX_HAVE__MODFF) && ! defined (_GLIBCXX_HAVE_MODFF) # define _GLIBCXX_HAVE_MODFF 1 # define modff _modff #endif #if defined (_GLIBCXX_HAVE__MODFL) && ! defined (_GLIBCXX_HAVE_MODFL) # define _GLIBCXX_HAVE_MODFL 1 # define modfl _modfl #endif #if defined (_GLIBCXX_HAVE__POWF) && ! defined (_GLIBCXX_HAVE_POWF) # define _GLIBCXX_HAVE_POWF 1 # define powf _powf #endif #if defined (_GLIBCXX_HAVE__POWL) && ! defined (_GLIBCXX_HAVE_POWL) # define _GLIBCXX_HAVE_POWL 1 # define powl _powl #endif #if defined (_GLIBCXX_HAVE__QFPCLASS) && ! defined (_GLIBCXX_HAVE_QFPCLASS) # define _GLIBCXX_HAVE_QFPCLASS 1 # define qfpclass _qfpclass #endif #if defined (_GLIBCXX_HAVE__SINCOS) && ! defined (_GLIBCXX_HAVE_SINCOS) # define _GLIBCXX_HAVE_SINCOS 1 # define sincos _sincos #endif #if defined (_GLIBCXX_HAVE__SINCOSF) && ! defined (_GLIBCXX_HAVE_SINCOSF) # define _GLIBCXX_HAVE_SINCOSF 1 # define sincosf _sincosf #endif #if defined (_GLIBCXX_HAVE__SINCOSL) && ! defined (_GLIBCXX_HAVE_SINCOSL) # define _GLIBCXX_HAVE_SINCOSL 1 # define sincosl _sincosl #endif #if defined (_GLIBCXX_HAVE__SINF) && ! defined (_GLIBCXX_HAVE_SINF) # define _GLIBCXX_HAVE_SINF 1 # define sinf _sinf #endif #if defined (_GLIBCXX_HAVE__SINHF) && ! defined (_GLIBCXX_HAVE_SINHF) # define _GLIBCXX_HAVE_SINHF 1 # define sinhf _sinhf #endif #if defined (_GLIBCXX_HAVE__SINHL) && ! defined (_GLIBCXX_HAVE_SINHL) # define _GLIBCXX_HAVE_SINHL 1 # define sinhl _sinhl #endif #if defined (_GLIBCXX_HAVE__SINL) && ! defined (_GLIBCXX_HAVE_SINL) # define _GLIBCXX_HAVE_SINL 1 # define sinl _sinl #endif #if defined (_GLIBCXX_HAVE__SQRTF) && ! defined (_GLIBCXX_HAVE_SQRTF) # define _GLIBCXX_HAVE_SQRTF 1 # define sqrtf _sqrtf #endif #if defined (_GLIBCXX_HAVE__SQRTL) && ! defined (_GLIBCXX_HAVE_SQRTL) # define _GLIBCXX_HAVE_SQRTL 1 # define sqrtl _sqrtl #endif #if defined (_GLIBCXX_HAVE__STRTOF) && ! defined (_GLIBCXX_HAVE_STRTOF) # define _GLIBCXX_HAVE_STRTOF 1 # define strtof _strtof #endif #if defined (_GLIBCXX_HAVE__STRTOLD) && ! defined (_GLIBCXX_HAVE_STRTOLD) # define _GLIBCXX_HAVE_STRTOLD 1 # define strtold _strtold #endif #if defined (_GLIBCXX_HAVE__TANF) && ! defined (_GLIBCXX_HAVE_TANF) # define _GLIBCXX_HAVE_TANF 1 # define tanf _tanf #endif #if defined (_GLIBCXX_HAVE__TANHF) && ! defined (_GLIBCXX_HAVE_TANHF) # define _GLIBCXX_HAVE_TANHF 1 # define tanhf _tanhf #endif #if defined (_GLIBCXX_HAVE__TANHL) && ! defined (_GLIBCXX_HAVE_TANHL) # define _GLIBCXX_HAVE_TANHL 1 # define tanhl _tanhl #endif #if defined (_GLIBCXX_HAVE__TANL) && ! defined (_GLIBCXX_HAVE_TANL) # define _GLIBCXX_HAVE_TANL 1 # define tanl _tanl #endif #endif // _GLIBCXX_CXX_CONFIG_H	63.18 KB	2025-09-15 15:42
📄 c++io.h // Underlying io library details -- C++ -- // Copyright (C) 2000-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/c++io.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{ios} */ // c_io_stdio.h - Defines for using "C" stdio.h #ifndef _GLIBCXX_CXX_IO_H #define _GLIBCXX_CXX_IO_H 1 #include <cstdio> #include <bits/gthr.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef __gthread_mutex_t __c_lock; // for basic_file.h typedef FILE __c_file; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif	1.57 KB	2025-09-15 15:41
📄 c++locale.h // Wrapper for underlying C-language localization -- C++ -- // Copyright (C) 2001-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/c++locale.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{locale} / // // ISO C++ 14882: 22.8 Standard locale categories. // // Written by Benjamin Kosnik <bkoz@redhat.com> #ifndef _GLIBCXX_CXX_LOCALE_H #define _GLIBCXX_CXX_LOCALE_H 1 #pragma GCC system_header #include <clocale> #define _GLIBCXX_C_LOCALE_GNU 1 #define _GLIBCXX_NUM_CATEGORIES 6 #if __GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION extern "C" __typeof(uselocale) __uselocale; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef __locale_t __c_locale; // Convert numeric value of type double and long double to string and // return length of string. If vsnprintf is available use it, otherwise // fall back to the unsafe vsprintf which, in general, can be dangerous // and should be avoided. inline int __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)), char __out, const int __size __attribute__ ((__unused__)), const char* __fmt, ...) { #if __GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) __c_locale __old = __gnu_cxx::__uselocale(__cloc); #else char* __old = std::setlocale(LC_NUMERIC, 0); char* __sav = 0; if (__builtin_strcmp(__old, "C")) { const size_t __len = __builtin_strlen(__old) + 1; __sav = new char[__len]; __builtin_memcpy(__sav, __old, __len); std::setlocale(LC_NUMERIC, "C"); } #endif __builtin_va_list __args; __builtin_va_start(__args, __fmt); #if _GLIBCXX_USE_C99_STDIO const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args); #else const int __ret = __builtin_vsprintf(__out, __fmt, __args); #endif __builtin_va_end(__args); #if __GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) __gnu_cxx::__uselocale(__old); #else if (__sav) { std::setlocale(LC_NUMERIC, __sav); delete [] __sav; } #endif return __ret; } _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif	3.23 KB	2025-09-15 15:41
📄 cpu_defines.h // Specific definitions for generic platforms -- C++ -- // Copyright (C) 2005-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/cpu_defines.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{iosfwd} */ #ifndef _GLIBCXX_CPU_DEFINES #define _GLIBCXX_CPU_DEFINES 1 #endif	1.3 KB	2025-09-15 15:41
📄 ctype_base.h // Locale support -- C++ -- // Copyright (C) 1997-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/ctype_base.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{locale} / // // ISO C++ 14882: 22.1 Locales // // Information as gleaned from /usr/include/ctype.h namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /// @brief Base class for ctype. struct ctype_base { // Non-standard typedefs. typedef const int __to_type; // NB: Offsets into ctype<char>::_M_table force a particular size // on the mask type. Because of this, we don't use an enum. typedef unsigned short mask; static const mask upper = _ISupper; static const mask lower = _ISlower; static const mask alpha = _ISalpha; static const mask digit = _ISdigit; static const mask xdigit = _ISxdigit; static const mask space = _ISspace; static const mask print = _ISprint; static const mask graph = _ISalpha \| _ISdigit \| _ISpunct; static const mask cntrl = _IScntrl; static const mask punct = _ISpunct; static const mask alnum = _ISalpha \| _ISdigit; #if __cplusplus >= 201103L static const mask blank = _ISblank; #endif }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace	2.26 KB	2025-09-15 15:41
📄 ctype_inline.h // Locale support -- C++ -- // Copyright (C) 2000-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/ctype_inline.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{locale} / // // ISO C++ 14882: 22.1 Locales // // ctype bits to be inlined go here. Non-inlinable (ie virtual do_) // functions go in ctype.cc namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION bool ctype<char>:: is(mask __m, char __c) const { return _M_table[static_cast<unsigned char>(__c)] & __m; } const char* ctype<char>:: is(const char* __low, const char* __high, mask* __vec) const { while (__low < __high) __vec++ = _M_table[static_cast<unsigned char>(__low++)]; return __high; } const char* ctype<char>:: scan_is(mask __m, const char* __low, const char* __high) const { while (__low < __high && !(_M_table[static_cast<unsigned char>(__low)] & __m)) ++__low; return __low; } const char ctype<char>:: scan_not(mask __m, const char* __low, const char* __high) const { while (__low < __high && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0) ++__low; return __low; } _GLIBCXX_END_NAMESPACE_VERSION } // namespace	2.23 KB	2025-09-15 15:41
📄 cxxabi_tweaks.h // Control various target specific ABI tweaks. Generic version. // Copyright (C) 2004-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/cxxabi_tweaks.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{cxxabi.h} / #ifndef _CXXABI_TWEAKS_H #define _CXXABI_TWEAKS_H 1 #ifdef __cplusplus namespace __cxxabiv1 { extern "C" { #endif // The generic ABI uses the first byte of a 64-bit guard variable. #define _GLIBCXX_GUARD_TEST(x) ((char ) (x) != 0) #define _GLIBCXX_GUARD_SET(x) (char *) (x) = 1 #define _GLIBCXX_GUARD_BIT __guard_test_bit (0, 1) #define _GLIBCXX_GUARD_PENDING_BIT __guard_test_bit (1, 1) #define _GLIBCXX_GUARD_WAITING_BIT __guard_test_bit (2, 1) __extension__ typedef int __guard __attribute__((mode (__DI__))); // __cxa_vec_ctor has void return type. typedef void __cxa_vec_ctor_return_type; #define _GLIBCXX_CXA_VEC_CTOR_RETURN(x) return // Constructors and destructors do not return a value. typedef void __cxa_cdtor_return_type; #ifdef __cplusplus } } // namespace __cxxabiv1 #endif #endif	2.05 KB	2025-09-15 15:41
📄 error_constants.h // Specific definitions for generic platforms -- C++ -- // Copyright (C) 2007-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/error_constants.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{system_error} */ #ifndef _GLIBCXX_ERROR_CONSTANTS #define _GLIBCXX_ERROR_CONSTANTS 1 #include <bits/c++config.h> #include <cerrno> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION enum class errc { address_family_not_supported = EAFNOSUPPORT, address_in_use = EADDRINUSE, address_not_available = EADDRNOTAVAIL, already_connected = EISCONN, argument_list_too_long = E2BIG, argument_out_of_domain = EDOM, bad_address = EFAULT, bad_file_descriptor = EBADF, #ifdef EBADMSG bad_message = EBADMSG, #endif broken_pipe = EPIPE, connection_aborted = ECONNABORTED, connection_already_in_progress = EALREADY, connection_refused = ECONNREFUSED, connection_reset = ECONNRESET, cross_device_link = EXDEV, destination_address_required = EDESTADDRREQ, device_or_resource_busy = EBUSY, directory_not_empty = ENOTEMPTY, executable_format_error = ENOEXEC, file_exists = EEXIST, file_too_large = EFBIG, filename_too_long = ENAMETOOLONG, function_not_supported = ENOSYS, host_unreachable = EHOSTUNREACH, #ifdef EIDRM identifier_removed = EIDRM, #endif illegal_byte_sequence = EILSEQ, inappropriate_io_control_operation = ENOTTY, interrupted = EINTR, invalid_argument = EINVAL, invalid_seek = ESPIPE, io_error = EIO, is_a_directory = EISDIR, message_size = EMSGSIZE, network_down = ENETDOWN, network_reset = ENETRESET, network_unreachable = ENETUNREACH, no_buffer_space = ENOBUFS, no_child_process = ECHILD, #ifdef ENOLINK no_link = ENOLINK, #endif no_lock_available = ENOLCK, #ifdef ENODATA no_message_available = ENODATA, #endif no_message = ENOMSG, no_protocol_option = ENOPROTOOPT, no_space_on_device = ENOSPC, #ifdef ENOSR no_stream_resources = ENOSR, #endif no_such_device_or_address = ENXIO, no_such_device = ENODEV, no_such_file_or_directory = ENOENT, no_such_process = ESRCH, not_a_directory = ENOTDIR, not_a_socket = ENOTSOCK, #ifdef ENOSTR not_a_stream = ENOSTR, #endif not_connected = ENOTCONN, not_enough_memory = ENOMEM, #ifdef ENOTSUP not_supported = ENOTSUP, #endif #ifdef ECANCELED operation_canceled = ECANCELED, #endif operation_in_progress = EINPROGRESS, operation_not_permitted = EPERM, operation_not_supported = EOPNOTSUPP, operation_would_block = EWOULDBLOCK, #ifdef EOWNERDEAD owner_dead = EOWNERDEAD, #endif permission_denied = EACCES, #ifdef EPROTO protocol_error = EPROTO, #endif protocol_not_supported = EPROTONOSUPPORT, read_only_file_system = EROFS, resource_deadlock_would_occur = EDEADLK, resource_unavailable_try_again = EAGAIN, result_out_of_range = ERANGE, #ifdef ENOTRECOVERABLE state_not_recoverable = ENOTRECOVERABLE, #endif #ifdef ETIME stream_timeout = ETIME, #endif #ifdef ETXTBSY text_file_busy = ETXTBSY, #endif timed_out = ETIMEDOUT, too_many_files_open_in_system = ENFILE, too_many_files_open = EMFILE, too_many_links = EMLINK, too_many_symbolic_link_levels = ELOOP, #ifdef EOVERFLOW value_too_large = EOVERFLOW, #elif defined __AVR__ value_too_large = 999, #endif wrong_protocol_type = EPROTOTYPE }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif	4.92 KB	2025-09-15 15:41
📄 extc++.h // C++ includes used for precompiling extensions -- C++ -- // Copyright (C) 2006-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file extc++.h * This is an implementation file for a precompiled header. */ #if __cplusplus < 201103L #include <bits/stdtr1c++.h> #else #include <bits/stdc++.h> #endif #include <ext/algorithm> #if __cplusplus >= 201103L # include <ext/aligned_buffer.h> #endif #include <ext/alloc_traits.h> #include <ext/atomicity.h> #include <ext/bitmap_allocator.h> #include <ext/cast.h> #if __cplusplus >= 201103L # include <ext/cmath> #endif #include <ext/concurrence.h> #include <ext/debug_allocator.h> #include <ext/extptr_allocator.h> #include <ext/functional> #include <ext/iterator> #include <ext/malloc_allocator.h> #include <ext/memory> #include <ext/mt_allocator.h> #include <ext/new_allocator.h> #include <ext/numeric> #include <ext/numeric_traits.h> #include <ext/pod_char_traits.h> #include <ext/pointer.h> #include <ext/pool_allocator.h> #if __cplusplus >= 201103L # include <ext/random> #endif #include <ext/rb_tree> #include <ext/rope> #include <ext/slist> #include <ext/stdio_filebuf.h> #include <ext/stdio_sync_filebuf.h> #include <ext/throw_allocator.h> #include <ext/typelist.h> #include <ext/type_traits.h> #include <ext/vstring.h> #include <ext/pb_ds/assoc_container.hpp> #include <ext/pb_ds/priority_queue.hpp> #include <ext/pb_ds/exception.hpp> #include <ext/pb_ds/hash_policy.hpp> #include <ext/pb_ds/list_update_policy.hpp> #include <ext/pb_ds/tree_policy.hpp> #include <ext/pb_ds/trie_policy.hpp> #ifdef _GLIBCXX_HAVE_ICONV #include <ext/codecvt_specializations.h> #include <ext/enc_filebuf.h> #endif	2.57 KB	2025-09-15 15:41
📄 gthr-default.h /* Threads compatibility routines for libgcc2 and libobjc. / / Compile this one with gcc. / / Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. / #ifndef _GLIBCXX_GCC_GTHR_POSIX_H #define _GLIBCXX_GCC_GTHR_POSIX_H / POSIX threads specific definitions. Easy, since the interface is just one-to-one mapping. / #define __GTHREADS 1 #define __GTHREADS_CXX0X 1 #include <pthread.h> #if ((defined(_LIBOBJC) \|\| defined(_LIBOBJC_WEAK)) \ \|\| !defined(_GTHREAD_USE_MUTEX_TIMEDLOCK)) # include <unistd.h> # if defined(_POSIX_TIMEOUTS) && _POSIX_TIMEOUTS >= 0 # define _GTHREAD_USE_MUTEX_TIMEDLOCK 1 # else # define _GTHREAD_USE_MUTEX_TIMEDLOCK 0 # endif #endif typedef pthread_t __gthread_t; typedef pthread_key_t __gthread_key_t; typedef pthread_once_t __gthread_once_t; typedef pthread_mutex_t __gthread_mutex_t; typedef pthread_mutex_t __gthread_recursive_mutex_t; typedef pthread_cond_t __gthread_cond_t; typedef struct timespec __gthread_time_t; / POSIX like conditional variables are supported. Please look at comments in gthr.h for details. / #define __GTHREAD_HAS_COND 1 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER) #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP #else #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function #endif #define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER #define __GTHREAD_TIME_INIT {0,0} #ifdef _GTHREAD_USE_MUTEX_INIT_FUNC # undef __GTHREAD_MUTEX_INIT #endif #ifdef _GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC # undef __GTHREAD_RECURSIVE_MUTEX_INIT # undef __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION # define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function #endif #ifdef _GTHREAD_USE_COND_INIT_FUNC # undef __GTHREAD_COND_INIT # define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init_function #endif #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK # ifndef __gthrw_pragma # define __gthrw_pragma(pragma) # endif # define __gthrw2(name,name2,type) \ static __typeof(type) name \ __attribute__ ((__weakref__(#name2), __copy__ (type))); \ __gthrw_pragma(weak type) # define __gthrw_(name) __gthrw_ ## name #else # define __gthrw2(name,name2,type) # define __gthrw_(name) name #endif / Typically, __gthrw_foo is a weak reference to symbol foo. / #define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name) __gthrw(pthread_once) __gthrw(pthread_getspecific) __gthrw(pthread_setspecific) __gthrw(pthread_create) __gthrw(pthread_join) __gthrw(pthread_equal) __gthrw(pthread_self) __gthrw(pthread_detach) #ifndef __BIONIC__ __gthrw(pthread_cancel) #endif __gthrw(sched_yield) __gthrw(pthread_mutex_lock) __gthrw(pthread_mutex_trylock) #if _GTHREAD_USE_MUTEX_TIMEDLOCK __gthrw(pthread_mutex_timedlock) #endif __gthrw(pthread_mutex_unlock) __gthrw(pthread_mutex_init) __gthrw(pthread_mutex_destroy) __gthrw(pthread_cond_init) __gthrw(pthread_cond_broadcast) __gthrw(pthread_cond_signal) __gthrw(pthread_cond_wait) __gthrw(pthread_cond_timedwait) __gthrw(pthread_cond_destroy) __gthrw(pthread_key_create) __gthrw(pthread_key_delete) __gthrw(pthread_mutexattr_init) __gthrw(pthread_mutexattr_settype) __gthrw(pthread_mutexattr_destroy) #if defined(_LIBOBJC) \|\| defined(_LIBOBJC_WEAK) / Objective-C. / __gthrw(pthread_exit) #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING __gthrw(sched_get_priority_max) __gthrw(sched_get_priority_min) #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _POSIX_PRIORITY_SCHEDULING / __gthrw(pthread_attr_destroy) __gthrw(pthread_attr_init) __gthrw(pthread_attr_setdetachstate) #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING __gthrw(pthread_getschedparam) __gthrw(pthread_setschedparam) #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _LIBOBJC \|\| _LIBOBJC_WEAK / #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK / On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if -pthreads is not specified. The functions are dummies and most return an error value. However pthread_once returns 0 without invoking the routine it is passed so we cannot pretend that the interface is active if -pthreads is not specified. On Solaris 2.5.1, the interface is not exposed at all so we need to play the usual game with weak symbols. On Solaris 10 and up, a working interface is always exposed. On FreeBSD 6 and later, libc also exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up to 9 does. FreeBSD >= 700014 even provides a pthread_cancel stub in libc, which means the alternate __gthread_active_p below cannot be used there. / #if defined(__FreeBSD__) \|\| (defined(__sun) && defined(__svr4__)) static volatile int __gthread_active = -1; static void __gthread_trigger (void) { __gthread_active = 1; } static inline int __gthread_active_p (void) { static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT; / Avoid reading __gthread_active twice on the main code path. / int __gthread_active_latest_value = __gthread_active; / This test is not protected to avoid taking a lock on the main code path so every update of __gthread_active in a threaded program must be atomic with regard to the result of the test. / if (__builtin_expect (__gthread_active_latest_value < 0, 0)) { if (__gthrw_(pthread_once)) { / If this really is a threaded program, then we must ensure that __gthread_active has been set to 1 before exiting this block. / __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex); __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger); __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex); } / Make sure we'll never enter this block again. / if (__gthread_active < 0) __gthread_active = 0; __gthread_active_latest_value = __gthread_active; } return __gthread_active_latest_value != 0; } #else / neither FreeBSD nor Solaris / / For a program to be multi-threaded the only thing that it certainly must be using is pthread_create. However, there may be other libraries that intercept pthread_create with their own definitions to wrap pthreads functionality for some purpose. In those cases, pthread_create being defined might not necessarily mean that libpthread is actually linked in. For the GNU C library, we can use a known internal name. This is always available in the ABI, but no other library would define it. That is ideal, since any public pthread function might be intercepted just as pthread_create might be. __pthread_key_create is an "internal" implementation symbol, but it is part of the public exported ABI. Also, it's among the symbols that the static libpthread.a always links in whenever pthread_create is used, so there is no danger of a false negative result in any statically-linked, multi-threaded program. For others, we choose pthread_cancel as a function that seems unlikely to be redefined by an interceptor library. The bionic (Android) C library does not provide pthread_cancel, so we do use pthread_create there (and interceptor libraries lose). / #ifdef __GLIBC__ __gthrw2(__gthrw_(__pthread_key_create), __pthread_key_create, pthread_key_create) # define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create) #elif defined (__BIONIC__) # define GTHR_ACTIVE_PROXY __gthrw_(pthread_create) #else # define GTHR_ACTIVE_PROXY __gthrw_(pthread_cancel) #endif static inline int __gthread_active_p (void) { static void const __gthread_active_ptr = __extension__ (void ) &GTHR_ACTIVE_PROXY; return __gthread_active_ptr != 0; } #endif / FreeBSD or Solaris / #else / not __GXX_WEAK__ / / Similar to Solaris, HP-UX 11 for PA-RISC provides stubs for pthread calls in shared flavors of the HP-UX C library. Most of the stubs have no functionality. The details are described in the "libc cumulative patch" for each subversion of HP-UX 11. There are two special interfaces provided for checking whether an application is linked to a shared pthread library or not. However, these interfaces aren't available in early libpthread libraries. We also need a test that works for archive libraries. We can't use pthread_once as some libc versions call the init function. We also can't use pthread_create or pthread_attr_init as these create a thread and thereby prevent changing the default stack size. The function pthread_default_stacksize_np is available in both the archive and shared versions of libpthread. It can be used to determine the default pthread stack size. There is a stub in some shared libc versions which returns a zero size if pthreads are not active. We provide an equivalent stub to handle cases where libc doesn't provide one. / #if defined(__hppa__) && defined(__hpux__) static volatile int __gthread_active = -1; static inline int __gthread_active_p (void) { / Avoid reading __gthread_active twice on the main code path. / int __gthread_active_latest_value = __gthread_active; size_t __s; if (__builtin_expect (__gthread_active_latest_value < 0, 0)) { pthread_default_stacksize_np (0, &__s); __gthread_active = __s ? 1 : 0; __gthread_active_latest_value = __gthread_active; } return __gthread_active_latest_value != 0; } #else / not hppa-hpux / static inline int __gthread_active_p (void) { return 1; } #endif / hppa-hpux / #endif / __GXX_WEAK__ / #ifdef _LIBOBJC / This is the config.h file in libobjc/ / #include <config.h> #ifdef HAVE_SCHED_H # include <sched.h> #endif / Key structure for maintaining thread specific storage / static pthread_key_t _objc_thread_storage; static pthread_attr_t _objc_thread_attribs; / Thread local storage for a single thread / static void thread_local_storage = NULL; /* Backend initialization functions / / Initialize the threads subsystem. / static inline int __gthread_objc_init_thread_system (void) { if (__gthread_active_p ()) { / Initialize the thread storage key. / if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0) { / The normal default detach state for threads is * PTHREAD_CREATE_JOINABLE which causes threads to not die * when you think they should. / if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0 && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs, PTHREAD_CREATE_DETACHED) == 0) return 0; } } return -1; } / Close the threads subsystem. / static inline int __gthread_objc_close_thread_system (void) { if (__gthread_active_p () && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0 && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0) return 0; return -1; } / Backend thread functions / / Create a new thread of execution. / static inline objc_thread_t __gthread_objc_thread_detach (void (func)(void ), void arg) { objc_thread_t thread_id; pthread_t new_thread_handle; if (!__gthread_active_p ()) return NULL; if (!(__gthrw_(pthread_create) (&new_thread_handle, &_objc_thread_attribs, (void ) func, arg))) thread_id = (objc_thread_t) new_thread_handle; else thread_id = NULL; return thread_id; } / Set the current thread's priority. / static inline int __gthread_objc_thread_set_priority (int priority) { if (!__gthread_active_p ()) return -1; else { #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING pthread_t thread_id = __gthrw_(pthread_self) (); int policy; struct sched_param params; int priority_min, priority_max; if (__gthrw_(pthread_getschedparam) (thread_id, &policy, &params) == 0) { if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1) return -1; if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1) return -1; if (priority > priority_max) priority = priority_max; else if (priority < priority_min) priority = priority_min; params.sched_priority = priority; / * The solaris 7 and several other man pages incorrectly state that * this should be a pointer to policy but pthread.h is universally * at odds with this. / if (__gthrw_(pthread_setschedparam) (thread_id, policy, &params) == 0) return 0; } #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _POSIX_PRIORITY_SCHEDULING / return -1; } } / Return the current thread's priority. / static inline int __gthread_objc_thread_get_priority (void) { #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING if (__gthread_active_p ()) { int policy; struct sched_param params; if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, &params) == 0) return params.sched_priority; else return -1; } else #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _POSIX_PRIORITY_SCHEDULING / return OBJC_THREAD_INTERACTIVE_PRIORITY; } / Yield our process time to another thread. / static inline void __gthread_objc_thread_yield (void) { if (__gthread_active_p ()) __gthrw_(sched_yield) (); } / Terminate the current thread. / static inline int __gthread_objc_thread_exit (void) { if (__gthread_active_p ()) / exit the thread / __gthrw_(pthread_exit) (&__objc_thread_exit_status); / Failed if we reached here / return -1; } / Returns an integer value which uniquely describes a thread. / static inline objc_thread_t __gthread_objc_thread_id (void) { if (__gthread_active_p ()) return (objc_thread_t) __gthrw_(pthread_self) (); else return (objc_thread_t) 1; } / Sets the thread's local storage pointer. / static inline int __gthread_objc_thread_set_data (void value) { if (__gthread_active_p ()) return __gthrw_(pthread_setspecific) (_objc_thread_storage, value); else { thread_local_storage = value; return 0; } } /* Returns the thread's local storage pointer. / static inline void __gthread_objc_thread_get_data (void) { if (__gthread_active_p ()) return __gthrw_(pthread_getspecific) (_objc_thread_storage); else return thread_local_storage; } /* Backend mutex functions / / Allocate a mutex. / static inline int __gthread_objc_mutex_allocate (objc_mutex_t mutex) { if (__gthread_active_p ()) { mutex->backend = objc_malloc (sizeof (pthread_mutex_t)); if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t ) mutex->backend, NULL)) { objc_free (mutex->backend); mutex->backend = NULL; return -1; } } return 0; } /* Deallocate a mutex. / static inline int __gthread_objc_mutex_deallocate (objc_mutex_t mutex) { if (__gthread_active_p ()) { int count; / * Posix Threads specifically require that the thread be unlocked * for __gthrw_(pthread_mutex_destroy) to work. / do { count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t ) mutex->backend); if (count < 0) return -1; } while (count); if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t ) mutex->backend)) return -1; objc_free (mutex->backend); mutex->backend = NULL; } return 0; } / Grab a lock on a mutex. / static inline int __gthread_objc_mutex_lock (objc_mutex_t mutex) { if (__gthread_active_p () && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t ) mutex->backend) != 0) { return -1; } return 0; } /* Try to grab a lock on a mutex. / static inline int __gthread_objc_mutex_trylock (objc_mutex_t mutex) { if (__gthread_active_p () && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t ) mutex->backend) != 0) { return -1; } return 0; } /* Unlock the mutex / static inline int __gthread_objc_mutex_unlock (objc_mutex_t mutex) { if (__gthread_active_p () && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t ) mutex->backend) != 0) { return -1; } return 0; } /* Backend condition mutex functions / / Allocate a condition. / static inline int __gthread_objc_condition_allocate (objc_condition_t condition) { if (__gthread_active_p ()) { condition->backend = objc_malloc (sizeof (pthread_cond_t)); if (__gthrw_(pthread_cond_init) ((pthread_cond_t ) condition->backend, NULL)) { objc_free (condition->backend); condition->backend = NULL; return -1; } } return 0; } /* Deallocate a condition. / static inline int __gthread_objc_condition_deallocate (objc_condition_t condition) { if (__gthread_active_p ()) { if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t ) condition->backend)) return -1; objc_free (condition->backend); condition->backend = NULL; } return 0; } /* Wait on the condition / static inline int __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_cond_wait) ((pthread_cond_t ) condition->backend, (pthread_mutex_t ) mutex->backend); else return 0; } / Wake up all threads waiting on this condition. / static inline int __gthread_objc_condition_broadcast (objc_condition_t condition) { if (__gthread_active_p ()) return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t ) condition->backend); else return 0; } /* Wake up one thread waiting on this condition. / static inline int __gthread_objc_condition_signal (objc_condition_t condition) { if (__gthread_active_p ()) return __gthrw_(pthread_cond_signal) ((pthread_cond_t ) condition->backend); else return 0; } #else /* _LIBOBJC / static inline int __gthread_create (__gthread_t __threadid, void (__func) (void), void __args) { return __gthrw_(pthread_create) (__threadid, NULL, __func, __args); } static inline int __gthread_join (__gthread_t __threadid, void *__value_ptr) { return __gthrw_(pthread_join) (__threadid, __value_ptr); } static inline int __gthread_detach (__gthread_t __threadid) { return __gthrw_(pthread_detach) (__threadid); } static inline int __gthread_equal (__gthread_t __t1, __gthread_t __t2) { return __gthrw_(pthread_equal) (__t1, __t2); } static inline __gthread_t __gthread_self (void) { return __gthrw_(pthread_self) (); } static inline int __gthread_yield (void) { return __gthrw_(sched_yield) (); } static inline int __gthread_once (__gthread_once_t __once, void (__func) (void)) { if (__gthread_active_p ()) return __gthrw_(pthread_once) (__once, __func); else return -1; } static inline int __gthread_key_create (__gthread_key_t __key, void (__dtor) (void )) { return __gthrw_(pthread_key_create) (__key, __dtor); } static inline int __gthread_key_delete (__gthread_key_t __key) { return __gthrw_(pthread_key_delete) (__key); } static inline void * __gthread_getspecific (__gthread_key_t __key) { return __gthrw_(pthread_getspecific) (__key); } static inline int __gthread_setspecific (__gthread_key_t __key, const void __ptr) { return __gthrw_(pthread_setspecific) (__key, __ptr); } static inline void __gthread_mutex_init_function (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) __gthrw_(pthread_mutex_init) (__mutex, NULL); } static inline int __gthread_mutex_destroy (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_destroy) (__mutex); else return 0; } static inline int __gthread_mutex_lock (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_lock) (__mutex); else return 0; } static inline int __gthread_mutex_trylock (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_trylock) (__mutex); else return 0; } #if _GTHREAD_USE_MUTEX_TIMEDLOCK static inline int __gthread_mutex_timedlock (__gthread_mutex_t __mutex, const __gthread_time_t __abs_timeout) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_timedlock) (__mutex, __abs_timeout); else return 0; } #endif static inline int __gthread_mutex_unlock (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_unlock) (__mutex); else return 0; } #if !defined( PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) \ \|\| defined(_GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC) static inline int __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t __mutex) { if (__gthread_active_p ()) { pthread_mutexattr_t __attr; int __r; __r = __gthrw_(pthread_mutexattr_init) (&__attr); if (!__r) __r = __gthrw_(pthread_mutexattr_settype) (&__attr, PTHREAD_MUTEX_RECURSIVE); if (!__r) __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr); if (!__r) __r = __gthrw_(pthread_mutexattr_destroy) (&__attr); return __r; } return 0; } #endif static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_lock (__mutex); } static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_trylock (__mutex); } #if _GTHREAD_USE_MUTEX_TIMEDLOCK static inline int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t __mutex, const __gthread_time_t __abs_timeout) { return __gthread_mutex_timedlock (__mutex, __abs_timeout); } #endif static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_unlock (__mutex); } static inline int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_destroy (__mutex); } #ifdef _GTHREAD_USE_COND_INIT_FUNC static inline void __gthread_cond_init_function (__gthread_cond_t __cond) { if (__gthread_active_p ()) __gthrw_(pthread_cond_init) (__cond, NULL); } #endif static inline int __gthread_cond_broadcast (__gthread_cond_t __cond) { return __gthrw_(pthread_cond_broadcast) (__cond); } static inline int __gthread_cond_signal (__gthread_cond_t __cond) { return __gthrw_(pthread_cond_signal) (__cond); } static inline int __gthread_cond_wait (__gthread_cond_t __cond, __gthread_mutex_t __mutex) { return __gthrw_(pthread_cond_wait) (__cond, __mutex); } static inline int __gthread_cond_timedwait (__gthread_cond_t __cond, __gthread_mutex_t __mutex, const __gthread_time_t __abs_timeout) { return __gthrw_(pthread_cond_timedwait) (__cond, __mutex, __abs_timeout); } static inline int __gthread_cond_wait_recursive (__gthread_cond_t __cond, __gthread_recursive_mutex_t __mutex) { return __gthread_cond_wait (__cond, __mutex); } static inline int __gthread_cond_destroy (__gthread_cond_t __cond) { return __gthrw_(pthread_cond_destroy) (__cond); } #endif /* _LIBOBJC / #endif / ! _GLIBCXX_GCC_GTHR_POSIX_H */	23.69 KB	2025-09-15 15:41
📄 gthr-posix.h /* Threads compatibility routines for libgcc2 and libobjc. / / Compile this one with gcc. / / Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. / #ifndef _GLIBCXX_GCC_GTHR_POSIX_H #define _GLIBCXX_GCC_GTHR_POSIX_H / POSIX threads specific definitions. Easy, since the interface is just one-to-one mapping. / #define __GTHREADS 1 #define __GTHREADS_CXX0X 1 #include <pthread.h> #if ((defined(_LIBOBJC) \|\| defined(_LIBOBJC_WEAK)) \ \|\| !defined(_GTHREAD_USE_MUTEX_TIMEDLOCK)) # include <unistd.h> # if defined(_POSIX_TIMEOUTS) && _POSIX_TIMEOUTS >= 0 # define _GTHREAD_USE_MUTEX_TIMEDLOCK 1 # else # define _GTHREAD_USE_MUTEX_TIMEDLOCK 0 # endif #endif typedef pthread_t __gthread_t; typedef pthread_key_t __gthread_key_t; typedef pthread_once_t __gthread_once_t; typedef pthread_mutex_t __gthread_mutex_t; typedef pthread_mutex_t __gthread_recursive_mutex_t; typedef pthread_cond_t __gthread_cond_t; typedef struct timespec __gthread_time_t; / POSIX like conditional variables are supported. Please look at comments in gthr.h for details. / #define __GTHREAD_HAS_COND 1 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER) #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP #else #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function #endif #define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER #define __GTHREAD_TIME_INIT {0,0} #ifdef _GTHREAD_USE_MUTEX_INIT_FUNC # undef __GTHREAD_MUTEX_INIT #endif #ifdef _GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC # undef __GTHREAD_RECURSIVE_MUTEX_INIT # undef __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION # define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function #endif #ifdef _GTHREAD_USE_COND_INIT_FUNC # undef __GTHREAD_COND_INIT # define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init_function #endif #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK # ifndef __gthrw_pragma # define __gthrw_pragma(pragma) # endif # define __gthrw2(name,name2,type) \ static __typeof(type) name \ __attribute__ ((__weakref__(#name2), __copy__ (type))); \ __gthrw_pragma(weak type) # define __gthrw_(name) __gthrw_ ## name #else # define __gthrw2(name,name2,type) # define __gthrw_(name) name #endif / Typically, __gthrw_foo is a weak reference to symbol foo. / #define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name) __gthrw(pthread_once) __gthrw(pthread_getspecific) __gthrw(pthread_setspecific) __gthrw(pthread_create) __gthrw(pthread_join) __gthrw(pthread_equal) __gthrw(pthread_self) __gthrw(pthread_detach) #ifndef __BIONIC__ __gthrw(pthread_cancel) #endif __gthrw(sched_yield) __gthrw(pthread_mutex_lock) __gthrw(pthread_mutex_trylock) #if _GTHREAD_USE_MUTEX_TIMEDLOCK __gthrw(pthread_mutex_timedlock) #endif __gthrw(pthread_mutex_unlock) __gthrw(pthread_mutex_init) __gthrw(pthread_mutex_destroy) __gthrw(pthread_cond_init) __gthrw(pthread_cond_broadcast) __gthrw(pthread_cond_signal) __gthrw(pthread_cond_wait) __gthrw(pthread_cond_timedwait) __gthrw(pthread_cond_destroy) __gthrw(pthread_key_create) __gthrw(pthread_key_delete) __gthrw(pthread_mutexattr_init) __gthrw(pthread_mutexattr_settype) __gthrw(pthread_mutexattr_destroy) #if defined(_LIBOBJC) \|\| defined(_LIBOBJC_WEAK) / Objective-C. / __gthrw(pthread_exit) #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING __gthrw(sched_get_priority_max) __gthrw(sched_get_priority_min) #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _POSIX_PRIORITY_SCHEDULING / __gthrw(pthread_attr_destroy) __gthrw(pthread_attr_init) __gthrw(pthread_attr_setdetachstate) #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING __gthrw(pthread_getschedparam) __gthrw(pthread_setschedparam) #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _LIBOBJC \|\| _LIBOBJC_WEAK / #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK / On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if -pthreads is not specified. The functions are dummies and most return an error value. However pthread_once returns 0 without invoking the routine it is passed so we cannot pretend that the interface is active if -pthreads is not specified. On Solaris 2.5.1, the interface is not exposed at all so we need to play the usual game with weak symbols. On Solaris 10 and up, a working interface is always exposed. On FreeBSD 6 and later, libc also exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up to 9 does. FreeBSD >= 700014 even provides a pthread_cancel stub in libc, which means the alternate __gthread_active_p below cannot be used there. / #if defined(__FreeBSD__) \|\| (defined(__sun) && defined(__svr4__)) static volatile int __gthread_active = -1; static void __gthread_trigger (void) { __gthread_active = 1; } static inline int __gthread_active_p (void) { static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT; / Avoid reading __gthread_active twice on the main code path. / int __gthread_active_latest_value = __gthread_active; / This test is not protected to avoid taking a lock on the main code path so every update of __gthread_active in a threaded program must be atomic with regard to the result of the test. / if (__builtin_expect (__gthread_active_latest_value < 0, 0)) { if (__gthrw_(pthread_once)) { / If this really is a threaded program, then we must ensure that __gthread_active has been set to 1 before exiting this block. / __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex); __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger); __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex); } / Make sure we'll never enter this block again. / if (__gthread_active < 0) __gthread_active = 0; __gthread_active_latest_value = __gthread_active; } return __gthread_active_latest_value != 0; } #else / neither FreeBSD nor Solaris / / For a program to be multi-threaded the only thing that it certainly must be using is pthread_create. However, there may be other libraries that intercept pthread_create with their own definitions to wrap pthreads functionality for some purpose. In those cases, pthread_create being defined might not necessarily mean that libpthread is actually linked in. For the GNU C library, we can use a known internal name. This is always available in the ABI, but no other library would define it. That is ideal, since any public pthread function might be intercepted just as pthread_create might be. __pthread_key_create is an "internal" implementation symbol, but it is part of the public exported ABI. Also, it's among the symbols that the static libpthread.a always links in whenever pthread_create is used, so there is no danger of a false negative result in any statically-linked, multi-threaded program. For others, we choose pthread_cancel as a function that seems unlikely to be redefined by an interceptor library. The bionic (Android) C library does not provide pthread_cancel, so we do use pthread_create there (and interceptor libraries lose). / #ifdef __GLIBC__ __gthrw2(__gthrw_(__pthread_key_create), __pthread_key_create, pthread_key_create) # define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create) #elif defined (__BIONIC__) # define GTHR_ACTIVE_PROXY __gthrw_(pthread_create) #else # define GTHR_ACTIVE_PROXY __gthrw_(pthread_cancel) #endif static inline int __gthread_active_p (void) { static void const __gthread_active_ptr = __extension__ (void ) &GTHR_ACTIVE_PROXY; return __gthread_active_ptr != 0; } #endif / FreeBSD or Solaris / #else / not __GXX_WEAK__ / / Similar to Solaris, HP-UX 11 for PA-RISC provides stubs for pthread calls in shared flavors of the HP-UX C library. Most of the stubs have no functionality. The details are described in the "libc cumulative patch" for each subversion of HP-UX 11. There are two special interfaces provided for checking whether an application is linked to a shared pthread library or not. However, these interfaces aren't available in early libpthread libraries. We also need a test that works for archive libraries. We can't use pthread_once as some libc versions call the init function. We also can't use pthread_create or pthread_attr_init as these create a thread and thereby prevent changing the default stack size. The function pthread_default_stacksize_np is available in both the archive and shared versions of libpthread. It can be used to determine the default pthread stack size. There is a stub in some shared libc versions which returns a zero size if pthreads are not active. We provide an equivalent stub to handle cases where libc doesn't provide one. / #if defined(__hppa__) && defined(__hpux__) static volatile int __gthread_active = -1; static inline int __gthread_active_p (void) { / Avoid reading __gthread_active twice on the main code path. / int __gthread_active_latest_value = __gthread_active; size_t __s; if (__builtin_expect (__gthread_active_latest_value < 0, 0)) { pthread_default_stacksize_np (0, &__s); __gthread_active = __s ? 1 : 0; __gthread_active_latest_value = __gthread_active; } return __gthread_active_latest_value != 0; } #else / not hppa-hpux / static inline int __gthread_active_p (void) { return 1; } #endif / hppa-hpux / #endif / __GXX_WEAK__ / #ifdef _LIBOBJC / This is the config.h file in libobjc/ / #include <config.h> #ifdef HAVE_SCHED_H # include <sched.h> #endif / Key structure for maintaining thread specific storage / static pthread_key_t _objc_thread_storage; static pthread_attr_t _objc_thread_attribs; / Thread local storage for a single thread / static void thread_local_storage = NULL; /* Backend initialization functions / / Initialize the threads subsystem. / static inline int __gthread_objc_init_thread_system (void) { if (__gthread_active_p ()) { / Initialize the thread storage key. / if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0) { / The normal default detach state for threads is * PTHREAD_CREATE_JOINABLE which causes threads to not die * when you think they should. / if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0 && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs, PTHREAD_CREATE_DETACHED) == 0) return 0; } } return -1; } / Close the threads subsystem. / static inline int __gthread_objc_close_thread_system (void) { if (__gthread_active_p () && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0 && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0) return 0; return -1; } / Backend thread functions / / Create a new thread of execution. / static inline objc_thread_t __gthread_objc_thread_detach (void (func)(void ), void arg) { objc_thread_t thread_id; pthread_t new_thread_handle; if (!__gthread_active_p ()) return NULL; if (!(__gthrw_(pthread_create) (&new_thread_handle, &_objc_thread_attribs, (void ) func, arg))) thread_id = (objc_thread_t) new_thread_handle; else thread_id = NULL; return thread_id; } / Set the current thread's priority. / static inline int __gthread_objc_thread_set_priority (int priority) { if (!__gthread_active_p ()) return -1; else { #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING pthread_t thread_id = __gthrw_(pthread_self) (); int policy; struct sched_param params; int priority_min, priority_max; if (__gthrw_(pthread_getschedparam) (thread_id, &policy, &params) == 0) { if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1) return -1; if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1) return -1; if (priority > priority_max) priority = priority_max; else if (priority < priority_min) priority = priority_min; params.sched_priority = priority; / * The solaris 7 and several other man pages incorrectly state that * this should be a pointer to policy but pthread.h is universally * at odds with this. / if (__gthrw_(pthread_setschedparam) (thread_id, policy, &params) == 0) return 0; } #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _POSIX_PRIORITY_SCHEDULING / return -1; } } / Return the current thread's priority. / static inline int __gthread_objc_thread_get_priority (void) { #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING if (__gthread_active_p ()) { int policy; struct sched_param params; if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, &params) == 0) return params.sched_priority; else return -1; } else #endif / _POSIX_THREAD_PRIORITY_SCHEDULING / #endif / _POSIX_PRIORITY_SCHEDULING / return OBJC_THREAD_INTERACTIVE_PRIORITY; } / Yield our process time to another thread. / static inline void __gthread_objc_thread_yield (void) { if (__gthread_active_p ()) __gthrw_(sched_yield) (); } / Terminate the current thread. / static inline int __gthread_objc_thread_exit (void) { if (__gthread_active_p ()) / exit the thread / __gthrw_(pthread_exit) (&__objc_thread_exit_status); / Failed if we reached here / return -1; } / Returns an integer value which uniquely describes a thread. / static inline objc_thread_t __gthread_objc_thread_id (void) { if (__gthread_active_p ()) return (objc_thread_t) __gthrw_(pthread_self) (); else return (objc_thread_t) 1; } / Sets the thread's local storage pointer. / static inline int __gthread_objc_thread_set_data (void value) { if (__gthread_active_p ()) return __gthrw_(pthread_setspecific) (_objc_thread_storage, value); else { thread_local_storage = value; return 0; } } /* Returns the thread's local storage pointer. / static inline void __gthread_objc_thread_get_data (void) { if (__gthread_active_p ()) return __gthrw_(pthread_getspecific) (_objc_thread_storage); else return thread_local_storage; } /* Backend mutex functions / / Allocate a mutex. / static inline int __gthread_objc_mutex_allocate (objc_mutex_t mutex) { if (__gthread_active_p ()) { mutex->backend = objc_malloc (sizeof (pthread_mutex_t)); if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t ) mutex->backend, NULL)) { objc_free (mutex->backend); mutex->backend = NULL; return -1; } } return 0; } /* Deallocate a mutex. / static inline int __gthread_objc_mutex_deallocate (objc_mutex_t mutex) { if (__gthread_active_p ()) { int count; / * Posix Threads specifically require that the thread be unlocked * for __gthrw_(pthread_mutex_destroy) to work. / do { count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t ) mutex->backend); if (count < 0) return -1; } while (count); if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t ) mutex->backend)) return -1; objc_free (mutex->backend); mutex->backend = NULL; } return 0; } / Grab a lock on a mutex. / static inline int __gthread_objc_mutex_lock (objc_mutex_t mutex) { if (__gthread_active_p () && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t ) mutex->backend) != 0) { return -1; } return 0; } /* Try to grab a lock on a mutex. / static inline int __gthread_objc_mutex_trylock (objc_mutex_t mutex) { if (__gthread_active_p () && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t ) mutex->backend) != 0) { return -1; } return 0; } /* Unlock the mutex / static inline int __gthread_objc_mutex_unlock (objc_mutex_t mutex) { if (__gthread_active_p () && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t ) mutex->backend) != 0) { return -1; } return 0; } /* Backend condition mutex functions / / Allocate a condition. / static inline int __gthread_objc_condition_allocate (objc_condition_t condition) { if (__gthread_active_p ()) { condition->backend = objc_malloc (sizeof (pthread_cond_t)); if (__gthrw_(pthread_cond_init) ((pthread_cond_t ) condition->backend, NULL)) { objc_free (condition->backend); condition->backend = NULL; return -1; } } return 0; } /* Deallocate a condition. / static inline int __gthread_objc_condition_deallocate (objc_condition_t condition) { if (__gthread_active_p ()) { if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t ) condition->backend)) return -1; objc_free (condition->backend); condition->backend = NULL; } return 0; } /* Wait on the condition / static inline int __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_cond_wait) ((pthread_cond_t ) condition->backend, (pthread_mutex_t ) mutex->backend); else return 0; } / Wake up all threads waiting on this condition. / static inline int __gthread_objc_condition_broadcast (objc_condition_t condition) { if (__gthread_active_p ()) return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t ) condition->backend); else return 0; } /* Wake up one thread waiting on this condition. / static inline int __gthread_objc_condition_signal (objc_condition_t condition) { if (__gthread_active_p ()) return __gthrw_(pthread_cond_signal) ((pthread_cond_t ) condition->backend); else return 0; } #else /* _LIBOBJC / static inline int __gthread_create (__gthread_t __threadid, void (__func) (void), void __args) { return __gthrw_(pthread_create) (__threadid, NULL, __func, __args); } static inline int __gthread_join (__gthread_t __threadid, void *__value_ptr) { return __gthrw_(pthread_join) (__threadid, __value_ptr); } static inline int __gthread_detach (__gthread_t __threadid) { return __gthrw_(pthread_detach) (__threadid); } static inline int __gthread_equal (__gthread_t __t1, __gthread_t __t2) { return __gthrw_(pthread_equal) (__t1, __t2); } static inline __gthread_t __gthread_self (void) { return __gthrw_(pthread_self) (); } static inline int __gthread_yield (void) { return __gthrw_(sched_yield) (); } static inline int __gthread_once (__gthread_once_t __once, void (__func) (void)) { if (__gthread_active_p ()) return __gthrw_(pthread_once) (__once, __func); else return -1; } static inline int __gthread_key_create (__gthread_key_t __key, void (__dtor) (void )) { return __gthrw_(pthread_key_create) (__key, __dtor); } static inline int __gthread_key_delete (__gthread_key_t __key) { return __gthrw_(pthread_key_delete) (__key); } static inline void * __gthread_getspecific (__gthread_key_t __key) { return __gthrw_(pthread_getspecific) (__key); } static inline int __gthread_setspecific (__gthread_key_t __key, const void __ptr) { return __gthrw_(pthread_setspecific) (__key, __ptr); } static inline void __gthread_mutex_init_function (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) __gthrw_(pthread_mutex_init) (__mutex, NULL); } static inline int __gthread_mutex_destroy (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_destroy) (__mutex); else return 0; } static inline int __gthread_mutex_lock (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_lock) (__mutex); else return 0; } static inline int __gthread_mutex_trylock (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_trylock) (__mutex); else return 0; } #if _GTHREAD_USE_MUTEX_TIMEDLOCK static inline int __gthread_mutex_timedlock (__gthread_mutex_t __mutex, const __gthread_time_t __abs_timeout) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_timedlock) (__mutex, __abs_timeout); else return 0; } #endif static inline int __gthread_mutex_unlock (__gthread_mutex_t __mutex) { if (__gthread_active_p ()) return __gthrw_(pthread_mutex_unlock) (__mutex); else return 0; } #if !defined( PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) \ \|\| defined(_GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC) static inline int __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t __mutex) { if (__gthread_active_p ()) { pthread_mutexattr_t __attr; int __r; __r = __gthrw_(pthread_mutexattr_init) (&__attr); if (!__r) __r = __gthrw_(pthread_mutexattr_settype) (&__attr, PTHREAD_MUTEX_RECURSIVE); if (!__r) __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr); if (!__r) __r = __gthrw_(pthread_mutexattr_destroy) (&__attr); return __r; } return 0; } #endif static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_lock (__mutex); } static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_trylock (__mutex); } #if _GTHREAD_USE_MUTEX_TIMEDLOCK static inline int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t __mutex, const __gthread_time_t __abs_timeout) { return __gthread_mutex_timedlock (__mutex, __abs_timeout); } #endif static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_unlock (__mutex); } static inline int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_destroy (__mutex); } #ifdef _GTHREAD_USE_COND_INIT_FUNC static inline void __gthread_cond_init_function (__gthread_cond_t __cond) { if (__gthread_active_p ()) __gthrw_(pthread_cond_init) (__cond, NULL); } #endif static inline int __gthread_cond_broadcast (__gthread_cond_t __cond) { return __gthrw_(pthread_cond_broadcast) (__cond); } static inline int __gthread_cond_signal (__gthread_cond_t __cond) { return __gthrw_(pthread_cond_signal) (__cond); } static inline int __gthread_cond_wait (__gthread_cond_t __cond, __gthread_mutex_t __mutex) { return __gthrw_(pthread_cond_wait) (__cond, __mutex); } static inline int __gthread_cond_timedwait (__gthread_cond_t __cond, __gthread_mutex_t __mutex, const __gthread_time_t __abs_timeout) { return __gthrw_(pthread_cond_timedwait) (__cond, __mutex, __abs_timeout); } static inline int __gthread_cond_wait_recursive (__gthread_cond_t __cond, __gthread_recursive_mutex_t __mutex) { return __gthread_cond_wait (__cond, __mutex); } static inline int __gthread_cond_destroy (__gthread_cond_t __cond) { return __gthrw_(pthread_cond_destroy) (__cond); } #endif /* _LIBOBJC / #endif / ! _GLIBCXX_GCC_GTHR_POSIX_H */	23.69 KB	2025-09-15 15:41
📄 gthr-single.h /* Threads compatibility routines for libgcc2 and libobjc. / / Compile this one with gcc. / / Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. / #ifndef _GLIBCXX_GCC_GTHR_SINGLE_H #define _GLIBCXX_GCC_GTHR_SINGLE_H / Just provide compatibility for mutex handling. / typedef int __gthread_key_t; typedef int __gthread_once_t; typedef int __gthread_mutex_t; typedef int __gthread_recursive_mutex_t; #define __GTHREAD_ONCE_INIT 0 #define __GTHREAD_MUTEX_INIT 0 #define __GTHREAD_MUTEX_INIT_FUNCTION(mx) do {} while (0) #define __GTHREAD_RECURSIVE_MUTEX_INIT 0 #define _GLIBCXX_UNUSED __attribute__((__unused__)) #ifdef _LIBOBJC / Thread local storage for a single thread / static void thread_local_storage = NULL; /* Backend initialization functions / / Initialize the threads subsystem. / static inline int __gthread_objc_init_thread_system (void) { / No thread support available / return -1; } / Close the threads subsystem. / static inline int __gthread_objc_close_thread_system (void) { / No thread support available / return -1; } / Backend thread functions / / Create a new thread of execution. / static inline objc_thread_t __gthread_objc_thread_detach (void ( func)(void ), void arg _GLIBCXX_UNUSED) { /* No thread support available / return NULL; } / Set the current thread's priority. / static inline int __gthread_objc_thread_set_priority (int priority _GLIBCXX_UNUSED) { / No thread support available / return -1; } / Return the current thread's priority. / static inline int __gthread_objc_thread_get_priority (void) { return OBJC_THREAD_INTERACTIVE_PRIORITY; } / Yield our process time to another thread. / static inline void __gthread_objc_thread_yield (void) { return; } / Terminate the current thread. / static inline int __gthread_objc_thread_exit (void) { / No thread support available / / Should we really exit the program / / exit (&__objc_thread_exit_status); / return -1; } / Returns an integer value which uniquely describes a thread. / static inline objc_thread_t __gthread_objc_thread_id (void) { / No thread support, use 1. / return (objc_thread_t) 1; } / Sets the thread's local storage pointer. / static inline int __gthread_objc_thread_set_data (void value) { thread_local_storage = value; return 0; } /* Returns the thread's local storage pointer. / static inline void __gthread_objc_thread_get_data (void) { return thread_local_storage; } /* Backend mutex functions / / Allocate a mutex. / static inline int __gthread_objc_mutex_allocate (objc_mutex_t mutex _GLIBCXX_UNUSED) { return 0; } / Deallocate a mutex. / static inline int __gthread_objc_mutex_deallocate (objc_mutex_t mutex _GLIBCXX_UNUSED) { return 0; } / Grab a lock on a mutex. / static inline int __gthread_objc_mutex_lock (objc_mutex_t mutex _GLIBCXX_UNUSED) { / There can only be one thread, so we always get the lock / return 0; } / Try to grab a lock on a mutex. / static inline int __gthread_objc_mutex_trylock (objc_mutex_t mutex _GLIBCXX_UNUSED) { / There can only be one thread, so we always get the lock / return 0; } / Unlock the mutex / static inline int __gthread_objc_mutex_unlock (objc_mutex_t mutex _GLIBCXX_UNUSED) { return 0; } / Backend condition mutex functions / / Allocate a condition. / static inline int __gthread_objc_condition_allocate (objc_condition_t condition _GLIBCXX_UNUSED) { return 0; } / Deallocate a condition. / static inline int __gthread_objc_condition_deallocate (objc_condition_t condition _GLIBCXX_UNUSED) { return 0; } / Wait on the condition / static inline int __gthread_objc_condition_wait (objc_condition_t condition _GLIBCXX_UNUSED, objc_mutex_t mutex _GLIBCXX_UNUSED) { return 0; } / Wake up all threads waiting on this condition. / static inline int __gthread_objc_condition_broadcast (objc_condition_t condition _GLIBCXX_UNUSED) { return 0; } / Wake up one thread waiting on this condition. / static inline int __gthread_objc_condition_signal (objc_condition_t condition _GLIBCXX_UNUSED) { return 0; } #else / _LIBOBJC / static inline int __gthread_active_p (void) { return 0; } static inline int __gthread_once (__gthread_once_t __once _GLIBCXX_UNUSED, void (__func) (void) _GLIBCXX_UNUSED) { return 0; } static inline int _GLIBCXX_UNUSED __gthread_key_create (__gthread_key_t __key _GLIBCXX_UNUSED, void (__func) (void ) _GLIBCXX_UNUSED) { return 0; } static int _GLIBCXX_UNUSED __gthread_key_delete (__gthread_key_t __key _GLIBCXX_UNUSED) { return 0; } static inline void * __gthread_getspecific (__gthread_key_t __key _GLIBCXX_UNUSED) { return 0; } static inline int __gthread_setspecific (__gthread_key_t __key _GLIBCXX_UNUSED, const void __v _GLIBCXX_UNUSED) { return 0; } static inline int __gthread_mutex_destroy (__gthread_mutex_t __mutex _GLIBCXX_UNUSED) { return 0; } static inline int __gthread_mutex_lock (__gthread_mutex_t __mutex _GLIBCXX_UNUSED) { return 0; } static inline int __gthread_mutex_trylock (__gthread_mutex_t __mutex _GLIBCXX_UNUSED) { return 0; } static inline int __gthread_mutex_unlock (__gthread_mutex_t __mutex _GLIBCXX_UNUSED) { return 0; } static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_lock (__mutex); } static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_trylock (__mutex); } static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_unlock (__mutex); } static inline int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t __mutex) { return __gthread_mutex_destroy (__mutex); } #endif / _LIBOBJC / #undef _GLIBCXX_UNUSED #endif / ! _GLIBCXX_GCC_GTHR_SINGLE_H */	6.65 KB	2025-09-15 15:41
📄 gthr.h /* Threads compatibility routines for libgcc2. / / Compile this one with gcc. / / Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. / #ifndef _GLIBCXX_GCC_GTHR_H #define _GLIBCXX_GCC_GTHR_H #ifndef _GLIBCXX_HIDE_EXPORTS #pragma GCC visibility push(default) #endif / If this file is compiled with threads support, it must #define __GTHREADS 1 to indicate that threads support is present. Also it has define function int __gthread_active_p () that returns 1 if thread system is active, 0 if not. The threads interface must define the following types: __gthread_key_t __gthread_once_t __gthread_mutex_t __gthread_recursive_mutex_t The threads interface must define the following macros: __GTHREAD_ONCE_INIT to initialize __gthread_once_t __GTHREAD_MUTEX_INIT to initialize __gthread_mutex_t to get a fast non-recursive mutex. __GTHREAD_MUTEX_INIT_FUNCTION to initialize __gthread_mutex_t to get a fast non-recursive mutex. Define this to a function which looks like this: void __GTHREAD_MUTEX_INIT_FUNCTION (__gthread_mutex_t ) Some systems can't initialize a mutex without a function call. Don't define __GTHREAD_MUTEX_INIT in this case. __GTHREAD_RECURSIVE_MUTEX_INIT __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION as above, but for a recursive mutex. The threads interface must define the following static functions: int __gthread_once (__gthread_once_t once, void (func) ()) int __gthread_key_create (__gthread_key_t keyp, void (dtor) (void )) int __gthread_key_delete (__gthread_key_t key) void __gthread_getspecific (__gthread_key_t key) int __gthread_setspecific (__gthread_key_t key, const void ptr) int __gthread_mutex_destroy (__gthread_mutex_t mutex); int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t mutex); int __gthread_mutex_lock (__gthread_mutex_t mutex); int __gthread_mutex_trylock (__gthread_mutex_t mutex); int __gthread_mutex_unlock (__gthread_mutex_t mutex); int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t mutex); int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t mutex); int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t mutex); The following are supported in POSIX threads only. They are required to fix a deadlock in static initialization inside libsupc++. The header file gthr-posix.h defines a symbol __GTHREAD_HAS_COND to signify that these extra features are supported. Types: __gthread_cond_t Macros: __GTHREAD_COND_INIT __GTHREAD_COND_INIT_FUNCTION Interface: int __gthread_cond_broadcast (__gthread_cond_t cond); int __gthread_cond_wait (__gthread_cond_t cond, __gthread_mutex_t mutex); int __gthread_cond_wait_recursive (__gthread_cond_t cond, __gthread_recursive_mutex_t mutex); All functions returning int should return zero on success or the error number. If the operation is not supported, -1 is returned. If the following are also defined, you should #define __GTHREADS_CXX0X 1 to enable the c++0x thread library. Types: __gthread_t __gthread_time_t Interface: int __gthread_create (__gthread_t thread, void (func) (void), void args); int __gthread_join (__gthread_t thread, void *value_ptr); int __gthread_detach (__gthread_t thread); int __gthread_equal (__gthread_t t1, __gthread_t t2); __gthread_t __gthread_self (void); int __gthread_yield (void); int __gthread_mutex_timedlock (__gthread_mutex_t m, const __gthread_time_t abs_timeout); int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t m, const __gthread_time_t abs_time); int __gthread_cond_signal (__gthread_cond_t cond); int __gthread_cond_timedwait (__gthread_cond_t cond, __gthread_mutex_t mutex, const __gthread_time_t abs_timeout); / #if __GXX_WEAK__ /* The pe-coff weak support isn't fully compatible to ELF's weak. For static libraries it might would work, but as we need to deal with shared versions too, we disable it for mingw-targets. / #ifdef __MINGW32__ #undef _GLIBCXX_GTHREAD_USE_WEAK #define _GLIBCXX_GTHREAD_USE_WEAK 0 #endif #ifndef _GLIBCXX_GTHREAD_USE_WEAK #define _GLIBCXX_GTHREAD_USE_WEAK 1 #endif #endif #include <bits/gthr-default.h> #ifndef _GLIBCXX_HIDE_EXPORTS #pragma GCC visibility pop #endif #endif / ! _GLIBCXX_GCC_GTHR_H */	5.48 KB	2025-09-15 15:41
📄 messages_members.h // std::messages implementation details, GNU version -- C++ -- // Copyright (C) 2001-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/messages_members.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{locale} / // // ISO C++ 14882: 22.2.7.1.2 messages functions // // Written by Benjamin Kosnik <bkoz@redhat.com> #include <libintl.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // Non-virtual member functions. template<typename _CharT> messages<_CharT>::messages(size_t __refs) : facet(__refs), _M_c_locale_messages(_S_get_c_locale()), _M_name_messages(_S_get_c_name()) { } template<typename _CharT> messages<_CharT>::messages(__c_locale __cloc, const char __s, size_t __refs) : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0) { if (__builtin_strcmp(__s, _S_get_c_name()) != 0) { const size_t __len = __builtin_strlen(__s) + 1; char* __tmp = new char[__len]; __builtin_memcpy(__tmp, __s, __len); _M_name_messages = __tmp; } else _M_name_messages = _S_get_c_name(); // Last to avoid leaking memory if new throws. _M_c_locale_messages = _S_clone_c_locale(__cloc); } template<typename _CharT> typename messages<_CharT>::catalog messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc, const char* __dir) const { bindtextdomain(__s.c_str(), __dir); return this->do_open(__s, __loc); } // Virtual member functions. template<typename _CharT> messages<_CharT>::~messages() { if (_M_name_messages != _S_get_c_name()) delete [] _M_name_messages; _S_destroy_c_locale(_M_c_locale_messages); } template<typename _CharT> typename messages<_CharT>::catalog messages<_CharT>::do_open(const basic_string<char>& __s, const locale&) const { // No error checking is done, assume the catalog exists and can // be used. textdomain(__s.c_str()); return 0; } template<typename _CharT> void messages<_CharT>::do_close(catalog) const { } // messages_byname template<typename _CharT> messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs) : messages<_CharT>(__refs) { if (this->_M_name_messages != locale::facet::_S_get_c_name()) { delete [] this->_M_name_messages; if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0) { const size_t __len = __builtin_strlen(__s) + 1; char* __tmp = new char[__len]; __builtin_memcpy(__tmp, __s, __len); this->_M_name_messages = __tmp; } else this->_M_name_messages = locale::facet::_S_get_c_name(); } if (__builtin_strcmp(__s, "C") != 0 && __builtin_strcmp(__s, "POSIX") != 0) { this->_S_destroy_c_locale(this->_M_c_locale_messages); this->_S_create_c_locale(this->_M_c_locale_messages, __s); } } //Specializations. template<> typename messages<char>::catalog messages<char>::do_open(const basic_string<char>&, const locale&) const; template<> void messages<char>::do_close(catalog) const; #ifdef _GLIBCXX_USE_WCHAR_T template<> typename messages<wchar_t>::catalog messages<wchar_t>::do_open(const basic_string<char>&, const locale&) const; template<> void messages<wchar_t>::do_close(catalog) const; #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace	4.41 KB	2025-09-15 15:41
📄 opt_random.h // Optimizations for random number functions, x86 version -- C++ -- // Copyright (C) 2012-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/opt_random.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{random} / #ifndef _BITS_OPT_RANDOM_H #define _BITS_OPT_RANDOM_H 1 #ifdef __SSE3__ #include <pmmintrin.h> #endif #pragma GCC system_header namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #ifdef __SSE3__ template<> template<typename _UniformRandomNumberGenerator> void normal_distribution<double>:: __generate(typename normal_distribution<double>::result_type __f, typename normal_distribution<double>::result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { typedef uint64_t __uctype; if (__f == __t) return; if (_M_saved_available) { _M_saved_available = false; __f++ = _M_saved __param.stddev() + __param.mean(); if (__f == __t) return; } constexpr uint64_t __maskval = 0xfffffffffffffull; static const __m128i __mask = _mm_set1_epi64x(__maskval); static const __m128i __two = _mm_set1_epi64x(0x4000000000000000ull); static const __m128d __three = _mm_set1_pd(3.0); const __m128d __av = _mm_set1_pd(__param.mean()); const __uctype __urngmin = __urng.min(); const __uctype __urngmax = __urng.max(); const __uctype __urngrange = __urngmax - __urngmin; const __uctype __uerngrange = __urngrange + 1; while (__f + 1 < __t) { double __le; __m128d __x; do { union { __m128i __i; __m128d __d; } __v; if (__urngrange > __maskval) { if (__detail::_Power_of_2(__uerngrange)) __v.__i = _mm_and_si128(_mm_set_epi64x(__urng(), __urng()), __mask); else { const __uctype __uerange = __maskval + 1; const __uctype __scaling = __urngrange / __uerange; const __uctype __past = __uerange * __scaling; uint64_t __v1; do __v1 = __uctype(__urng()) - __urngmin; while (__v1 >= __past); __v1 /= __scaling; uint64_t __v2; do __v2 = __uctype(__urng()) - __urngmin; while (__v2 >= __past); __v2 /= __scaling; __v.__i = _mm_set_epi64x(__v1, __v2); } } else if (__urngrange == __maskval) __v.__i = _mm_set_epi64x(__urng(), __urng()); else if ((__urngrange + 2) * __urngrange >= __maskval && __detail::_Power_of_2(__uerngrange)) { uint64_t __v1 = __urng() * __uerngrange + __urng(); uint64_t __v2 = __urng() * __uerngrange + __urng(); __v.__i = _mm_and_si128(_mm_set_epi64x(__v1, __v2), __mask); } else { size_t __nrng = 2; __uctype __high = __maskval / __uerngrange / __uerngrange; while (__high > __uerngrange) { ++__nrng; __high /= __uerngrange; } const __uctype __highrange = __high + 1; const __uctype __scaling = __urngrange / __highrange; const __uctype __past = __highrange * __scaling; __uctype __tmp; uint64_t __v1; do { do __tmp = __uctype(__urng()) - __urngmin; while (__tmp >= __past); __v1 = __tmp / __scaling; for (size_t __cnt = 0; __cnt < __nrng; ++__cnt) { __tmp = __v1; __v1 = __uerngrange; __v1 += __uctype(__urng()) - __urngmin; } } while (__v1 > __maskval \|\| __v1 < __tmp); uint64_t __v2; do { do __tmp = __uctype(__urng()) - __urngmin; while (__tmp >= __past); __v2 = __tmp / __scaling; for (size_t __cnt = 0; __cnt < __nrng; ++__cnt) { __tmp = __v2; __v2 = __uerngrange; __v2 += __uctype(__urng()) - __urngmin; } } while (__v2 > __maskval \|\| __v2 < __tmp); __v.__i = _mm_set_epi64x(__v1, __v2); } __v.__i = _mm_or_si128(__v.__i, __two); __x = _mm_sub_pd(__v.__d, __three); __m128d __m = _mm_mul_pd(__x, __x); __le = _mm_cvtsd_f64(_mm_hadd_pd (__m, __m)); } while (__le == 0.0 \|\| __le >= 1.0); double __mult = (std::sqrt(-2.0 * std::log(__le) / __le) * __param.stddev()); __x = _mm_add_pd(_mm_mul_pd(__x, _mm_set1_pd(__mult)), __av); _mm_storeu_pd(__f, __x); __f += 2; } if (__f != __t) { result_type __x, __y, __r2; __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); do { __x = result_type(2.0) * __aurng() - 1.0; __y = result_type(2.0) * __aurng() - 1.0; __r2 = __x * __x + __y * __y; } while (__r2 > 1.0 \|\| __r2 == 0.0); const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); _M_saved = __x * __mult; _M_saved_available = true; __f = __y __mult * __param.stddev() + __param.mean(); } } #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif // _BITS_OPT_RANDOM_H	6.05 KB	2025-09-15 15:41
📄 os_defines.h // Specific definitions for GNU/Linux -- C++ -- // Copyright (C) 2000-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/os_defines.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{iosfwd} */ #ifndef _GLIBCXX_OS_DEFINES #define _GLIBCXX_OS_DEFINES 1 // System-specific #define, typedefs, corrections, etc, go here. This // file will come before all others. // This keeps isanum, et al from being propagated as macros. #define __NO_CTYPE 1 #include <features.h> // Provide a declaration for the possibly deprecated gets function, as // glibc 2.15 and later does not declare gets for ISO C11 when // __GNU_SOURCE is defined. #if __GLIBC_PREREQ(2,15) && defined(_GNU_SOURCE) # undef _GLIBCXX_HAVE_GETS #endif // Glibc 2.23 removed the obsolete isinf and isnan declarations. Check the // version dynamically in case it has changed since libstdc++ was configured. #define _GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC __GLIBC_PREREQ(2,23) #if __GLIBC_PREREQ(2, 27) // Since glibc 2.27 pthread_self() is usable without linking to libpthread. # define _GLIBCXX_NATIVE_THREAD_ID pthread_self() #else // Before then it was in libc.so.6 but not libc.a, and always returns 0, // which breaks the invariant this_thread::get_id() != thread::id{}. // So only use it if we know the libpthread version is available. // Otherwise use (__gthread_t)1 as the ID of the main (and only) thread. # define _GLIBCXX_NATIVE_THREAD_ID \ (__gthread_active_p() ? __gthread_self() : (__gthread_t)1) #endif #if __GLIBC_PREREQ(2, 34) // Since glibc 2.34 all pthreads functions are usable without linking to // libpthread. # define _GLIBCXX_GTHREAD_USE_WEAK 0 #endif #endif	2.65 KB	2025-09-15 15:41
📄 stdc++.h // C++ includes used for precompiling -- C++ -- // Copyright (C) 2003-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file stdc++.h * This is an implementation file for a precompiled header. */ // 17.4.1.2 Headers // C #ifndef _GLIBCXX_NO_ASSERT #include <cassert> #endif #include <cctype> #include <cerrno> #include <cfloat> #include <ciso646> #include <climits> #include <clocale> #include <cmath> #include <csetjmp> #include <csignal> #include <cstdarg> #include <cstddef> #include <cstdio> #include <cstdlib> #include <cstring> #include <ctime> #include <cwchar> #include <cwctype> #if __cplusplus >= 201103L #include <ccomplex> #include <cfenv> #include <cinttypes> #include <cstdalign> #include <cstdbool> #include <cstdint> #include <ctgmath> #include <cuchar> #endif // C++ #include <algorithm> #include <bitset> #include <complex> #include <deque> #include <exception> #include <fstream> #include <functional> #include <iomanip> #include <ios> #include <iosfwd> #include <iostream> #include <istream> #include <iterator> #include <limits> #include <list> #include <locale> #include <map> #include <memory> #include <new> #include <numeric> #include <ostream> #include <queue> #include <set> #include <sstream> #include <stack> #include <stdexcept> #include <streambuf> #include <string> #include <typeinfo> #include <utility> #include <valarray> #include <vector> #if __cplusplus >= 201103L #include <array> #include <atomic> #include <chrono> #include <codecvt> #include <condition_variable> #include <forward_list> #include <future> #include <initializer_list> #include <mutex> #include <random> #include <ratio> #include <regex> #include <scoped_allocator> #include <system_error> #include <thread> #include <tuple> #include <typeindex> #include <type_traits> #include <unordered_map> #include <unordered_set> #endif #if __cplusplus >= 201402L #include <shared_mutex> #endif #if __cplusplus >= 201703L #include <any> #include <charconv> // #include <execution> #include <filesystem> #include <optional> #include <memory_resource> #include <string_view> #include <variant> #endif #if __cplusplus > 201703L #include <barrier> #include <bit> #include <compare> #include <concepts> #if __cpp_impl_coroutine # include <coroutine> #endif #include <latch> #include <numbers> #include <ranges> #include <span> #include <stop_token> #include <semaphore> #include <source_location> #include <syncstream> #include <version> #endif	3.34 KB	2025-09-15 15:41
📄 stdtr1c++.h // C++ includes used for precompiling TR1 -- C++ -- // Copyright (C) 2006-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file stdtr1c++.h * This is an implementation file for a precompiled header. */ #include <bits/stdc++.h> #include <tr1/array> #include <tr1/cctype> #include <tr1/cfenv> #include <tr1/cfloat> #include <tr1/cinttypes> #include <tr1/climits> #include <tr1/cmath> #include <tr1/complex> #include <tr1/cstdarg> #include <tr1/cstdbool> #include <tr1/cstdint> #include <tr1/cstdio> #include <tr1/cstdlib> #include <tr1/ctgmath> #include <tr1/ctime> #include <tr1/cwchar> #include <tr1/cwctype> #include <tr1/functional> #include <tr1/random> #include <tr1/tuple> #include <tr1/unordered_map> #include <tr1/unordered_set> #include <tr1/utility>	1.7 KB	2025-09-15 15:41
📄 time_members.h // std::time_get, std::time_put implementation, GNU version -- C++ -- // Copyright (C) 2001-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file bits/time_members.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{locale} / // // ISO C++ 14882: 22.2.5.1.2 - time_get functions // ISO C++ 14882: 22.2.5.3.2 - time_put functions // // Written by Benjamin Kosnik <bkoz@redhat.com> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _CharT> __timepunct<_CharT>::__timepunct(size_t __refs) : facet(__refs), _M_data(0), _M_c_locale_timepunct(0), _M_name_timepunct(_S_get_c_name()) { _M_initialize_timepunct(); } template<typename _CharT> __timepunct<_CharT>::__timepunct(__cache_type __cache, size_t __refs) : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0), _M_name_timepunct(_S_get_c_name()) { _M_initialize_timepunct(); } template<typename _CharT> __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s, size_t __refs) : facet(__refs), _M_data(0), _M_c_locale_timepunct(0), _M_name_timepunct(0) { if (__builtin_strcmp(__s, _S_get_c_name()) != 0) { const size_t __len = __builtin_strlen(__s) + 1; char* __tmp = new char[__len]; __builtin_memcpy(__tmp, __s, __len); _M_name_timepunct = __tmp; } else _M_name_timepunct = _S_get_c_name(); __try { _M_initialize_timepunct(__cloc); } __catch(...) { if (_M_name_timepunct != _S_get_c_name()) delete [] _M_name_timepunct; __throw_exception_again; } } template<typename _CharT> __timepunct<_CharT>::~__timepunct() { if (_M_name_timepunct != _S_get_c_name()) delete [] _M_name_timepunct; delete _M_data; _S_destroy_c_locale(_M_c_locale_timepunct); } _GLIBCXX_END_NAMESPACE_VERSION } // namespace	2.86 KB	2025-09-15 15:41

Edit File:

Terminal