[[분류:웹사이트]] ==개요== 코딩 테스트 문제를 모아놓은 국내 웹사이트 중 가장 규모가 큰 곳이다. solved.ac를 통해 문제의 티어(브론즈/실버/골드/플래티넘/다이아/루비 V~I)를 알 수 있다. [* 내신 문제는 거의 브론즈밖에 없다고 보면 된다.] 2026년 4월 28일 서버를 종료하였다. [* LLM이 문제를 잘 풀어 코딩 테스트가 의미가 없어져서 재정 문제에 문제가 생겼다는 찌라시가 있었지만 사실이 아니다.] ==인천과학고등학교에서== 2026년 3월 20일 기준, 전국 고등학교 중 37위이다. [[https://www.acmicpc.net/ranklist/high|#]] ===2026년 이전=== [[RAIBIT]]에서 백준을 딱 '한 번' 풀었다. [[https://www.acmicpc.net/group/23290|인천과학고등학교 정보 동아리 RAIBIT]] ---- 또한, 가끔씩 백준을 돌아다니다 보면 {{{#!syntax python f"ishs{기수}{학번}" # 28? <= 기수 <= 31 }}} 꼴의 아이디가 많이 나타나는 것으로 보아 [[ishs01.com|자체 방과후 사이트]]로 공부한 32기와 달리 이전 정보 수업 때는 백준을 활용했던 것으로 보인다. [[https://www.acmicpc.net/school/ranklist/444|#]] ===2026년=== [[RAIBIT]]에서 2026년 32기, 33기를 대상으로 한 그룹을 만들었다. [[https://www.acmicpc.net/group/25265|2026 인천과학고등학교 RAIBIT]] 문제집을 누르면 간단하게 풀 수 있는 문제들이 있다.[* 입출력, 조건문, 반복문, 재귀 순서로 대부분 브론즈 문제이다. 특별한 스킬이 필요한 문제는 없고 이정도만 풀어도 [[정보(교과목)|정보]] 내신은 잘 나온다.] ==다른 영과고에서== 백준을 이용하여 대회를 열거나 교내 대회 문제를 백준에 올리기도 한다. 평균적으로 골드 I 정도의 문제들이 많으며 코딩 실력보다는 (이산)수학 실력이 매우 중요하다.[* 정보올림피아드 1교시 문제도 다 이런 문제들이다][* 0-1 배낭 문제, 위상 정렬, BFS/DFS, 최단 경로(다익스트라, 플로이드-워셜, 벨만-포드), 최소 신장 트리(크루스칼, 프림), 비트마스킹, 그리디 알고리즘, 분할 정복, 이분 탐색, 세그먼트 트리(구간 쿼리), 유클리드 호제법, 조합론, 해시, 게임 이론 등 이 모든 것이 안 쓰이는 것이 없다.] 선린인터넷고나 디미고 같은 학교들은 특성화고임에도 영과고생보다 뛰어난 실적을 보여주기도 한다. [[https://www.acmicpc.net/category/364|경기과학고]] [[https://www.acmicpc.net/category/630|경기북과학고]] [[https://www.acmicpc.net/category/417|대구과학고]] [[https://www.acmicpc.net/category/1074|대전과학고]] [[https://www.acmicpc.net/category/435|서울과학고]] [[https://www.acmicpc.net/category/610|세과영]] [[https://www.acmicpc.net/category/542|한과영]] [[https://www.acmicpc.net/category/429|부산일과학고]] [[https://www.acmicpc.net/category/1051|한성과학고]] ==문제 예시== ===1000번=== 가장 첫번째 문제인 1000번(브론즈 V)은 매우 어려운 문제 중 하나이다. [[https://www.acmicpc.net/problem/1000|#]] > '''문제''' > 두 정수 A와 B를 입력받은 다음,[br]A+B를 출력하는 프로그램을 작성하시오. > > '''입력''' > 첫째 줄에 A와 B가 주어진다. (0 < A, B < 10) > > '''출력''' > 첫째 줄에 A+B를 출력한다. > > '''예제 입력 1''' '''예제 출력 1''' > 1 2 3 > > ====#해답#==== [[C++]] 기준으로 작성된 코드이다. {{{#!syntax cpp #ifndef _STDIO_H_ #ifdef __cplusplus extern "C" { #endif #define _STDIO_H_ #define _FSTDIO /* ``function stdio'' */ #define __need_size_t #if (!defined(_STDDEF_H) && !defined(_STDDEF_H_) && !defined(_ANSI_STDDEF_H) \ && !defined(__STDDEF_H__)) \ || defined(__need_wchar_t) || defined(__need_size_t) \ || defined(__need_ptrdiff_t) || defined(__need_NULL) \ || defined(__need_wint_t) #if (!defined(__need_wchar_t) && !defined(__need_size_t) \ && !defined(__need_ptrdiff_t) && !defined(__need_NULL) \ && !defined(__need_wint_t)) #define _STDDEF_H #define _STDDEF_H_ #define _ANSI_STDDEF_H #endif #ifndef __sys_stdtypes_h #if defined(__NetBSD__) #endif #if defined (__FreeBSD__) #ifndef _SYS__TYPES_H_ #define _SYS__TYPES_H_ typedef __int64_t __blkcnt_t; /* blocks allocated for file */ typedef __int32_t __blksize_t; /* optimal blocksize for I/O */ typedef __int64_t __clock_t; /* ticks in CLOCKS_PER_SEC */ typedef __int32_t __clockid_t; /* CLOCK_* identifiers */ typedef unsigned long __cpuid_t; /* CPU id */ typedef __int32_t __dev_t; /* device number */ typedef __uint32_t __fixpt_t; /* fixed point number */ typedef __uint64_t __fsblkcnt_t; /* file system block count */ typedef __uint64_t __fsfilcnt_t; /* file system file count */ typedef __uint32_t __gid_t; /* group id */ typedef __uint32_t __id_t; /* may contain pid, uid or gid */ typedef __uint32_t __in_addr_t; /* base type for internet address */ typedef __uint16_t __in_port_t; /* IP port type */ typedef __uint64_t __ino_t; /* inode number */ typedef long __key_t; /* IPC key (for Sys V IPC) */ typedef __uint32_t __mode_t; /* permissions */ typedef __uint32_t __nlink_t; /* link count */ typedef __int64_t __off_t; /* file offset or size */ typedef __int32_t __pid_t; /* process id */ typedef __uint64_t __rlim_t; /* resource limit */ typedef __uint8_t __sa_family_t; /* sockaddr address family type */ typedef __int32_t __segsz_t; /* segment size */ typedef __uint32_t __socklen_t; /* length type for network syscalls */ typedef long __suseconds_t; /* microseconds (signed) */ typedef __int64_t __time_t; /* epoch time */ typedef __int32_t __timer_t; /* POSIX timer identifiers */ typedef __uint32_t __uid_t; /* user id */ typedef __uint32_t __useconds_t; /* microseconds */ /* * mbstate_t is an opaque object to keep conversion state, during multibyte * stream conversions. The content must not be referenced by user programs. */ typedef union { char __mbstate8[128]; __int64_t __mbstateL; /* for alignment */ } __mbstate_t; #endif /* !_SYS__TYPES_H_ */ #endif #if defined(__NetBSD__) #if !defined(_SIZE_T_) && !defined(_BSD_SIZE_T_) #define _SIZE_T #endif #if !defined(_PTRDIFF_T_) && !defined(_BSD_PTRDIFF_T_) #define _PTRDIFF_T #endif /* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_ instead of _WCHAR_T_. */ #if !defined(_WCHAR_T_) && !defined(_BSD_WCHAR_T_) #ifndef _BSD_WCHAR_T_ #define _WCHAR_T #endif #endif /* Undef _FOO_T_ if we are supposed to define foo_t. */ #if defined (__need_ptrdiff_t) || defined (_STDDEF_H_) #undef _PTRDIFF_T_ #undef _BSD_PTRDIFF_T_ #endif #if defined (__need_size_t) || defined (_STDDEF_H_) #undef _SIZE_T_ #undef _BSD_SIZE_T_ #endif #if defined (__need_wchar_t) || defined (_STDDEF_H_) #undef _WCHAR_T_ #undef _BSD_WCHAR_T_ #endif #endif /* defined(__NetBSD__) */ /* Sequent's header files use _PTRDIFF_T_ in some conflicting way. Just ignore it. */ #if defined (__sequent__) && defined (_PTRDIFF_T_) #undef _PTRDIFF_T_ #endif /* When modular code is enabled with macOS SDKs from version 15, the include guards are set in the includers of this code, rather than as part of it. This means the we must unset them or the intended code here will be bypassed (resulting in undefined values). */ #if defined (__APPLE__) # if defined(__has_feature) && __has_feature(modules) # if defined (__need_ptrdiff_t) # undef __PTRDIFF_T # endif # if defined (__need_size_t) # undef __SIZE_T # endif # endif #endif /* On VxWorks, <type/vxTypesBase.h> may have defined macros like _TYPE_size_t which will typedef size_t. fixincludes patched the vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is not defined, and so that defining this macro defines _GCC_SIZE_T. If we find that the macros are still defined at this point, we must invoke them so that the type is defined as expected. */ #if defined (_TYPE_ptrdiff_t) && (defined (__need_ptrdiff_t) || defined (_STDDEF_H_)) _TYPE_ptrdiff_t; #undef _TYPE_ptrdiff_t #endif #if defined (_TYPE_size_t) && (defined (__need_size_t) || defined (_STDDEF_H_)) _TYPE_size_t; #undef _TYPE_size_t #endif #if defined (_TYPE_wchar_t) && (defined (__need_wchar_t) || defined (_STDDEF_H_)) _TYPE_wchar_t; #undef _TYPE_wchar_t #endif /* In case nobody has defined these types, but we aren't running under GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and __WCHAR_TYPE__ have reasonable values. This can happen if the parts of GCC is compiled by an older compiler, that actually include gstddef.h, such as collect2. */ /* Signed type of difference of two pointers. */ /* Define this type if we are doing the whole job, or if we want this type in particular. */ #if defined (_STDDEF_H) || defined (__need_ptrdiff_t) #ifndef _PTRDIFF_T /* in case <sys/types.h> has defined it. */ #ifndef _T_PTRDIFF_ #ifndef _T_PTRDIFF #ifndef __PTRDIFF_T #ifndef _PTRDIFF_T_ #ifndef _BSD_PTRDIFF_T_ #ifndef ___int_ptrdiff_t_h #ifndef _GCC_PTRDIFF_T #ifndef _PTRDIFF_T_DECLARED /* DragonFly */ #ifndef __DEFINED_ptrdiff_t /* musl libc */ #define _PTRDIFF_T #define _T_PTRDIFF_ #define _T_PTRDIFF #define __PTRDIFF_T #define _PTRDIFF_T_ #define _BSD_PTRDIFF_T_ #define ___int_ptrdiff_t_h #define _GCC_PTRDIFF_T #define _PTRDIFF_T_DECLARED #define __DEFINED_ptrdiff_t #ifndef __PTRDIFF_TYPE__ #define __PTRDIFF_TYPE__ long int #endif typedef __PTRDIFF_TYPE__ ptrdiff_t; #endif /* __DEFINED_ptrdiff_t */ #endif /* _PTRDIFF_T_DECLARED */ #endif /* _GCC_PTRDIFF_T */ #endif /* ___int_ptrdiff_t_h */ #endif /* _BSD_PTRDIFF_T_ */ #endif /* _PTRDIFF_T_ */ #endif /* __PTRDIFF_T */ #endif /* _T_PTRDIFF */ #endif /* _T_PTRDIFF_ */ #endif /* _PTRDIFF_T */ /* If this symbol has done its job, get rid of it. */ #undef __need_ptrdiff_t #endif /* _STDDEF_H or __need_ptrdiff_t. */ /* Unsigned type of `sizeof' something. */ /* Define this type if we are doing the whole job, or if we want this type in particular. */ #if defined (_STDDEF_H) || defined (__need_size_t) #ifndef __size_t__ /* BeOS */ #ifndef __SIZE_T__ /* Cray Unicos/Mk */ #ifndef _SIZE_T /* in case <sys/types.h> has defined it. */ #ifndef _SYS_SIZE_T_H #ifndef _T_SIZE_ #ifndef _T_SIZE #ifndef __SIZE_T #ifndef _SIZE_T_ #ifndef _BSD_SIZE_T_ #ifndef _SIZE_T_DEFINED_ #ifndef _SIZE_T_DEFINED #ifndef _BSD_SIZE_T_DEFINED_ /* Darwin */ #ifndef _SIZE_T_DECLARED /* FreeBSD 5 */ #ifndef __DEFINED_size_t /* musl libc */ #ifndef ___int_size_t_h #ifndef _GCC_SIZE_T #ifndef _SIZET_ #ifndef __size_t #define __size_t__ /* BeOS */ #define __SIZE_T__ /* Cray Unicos/Mk */ #define _SIZE_T #define _SYS_SIZE_T_H #define _T_SIZE_ #define _T_SIZE #define __SIZE_T #define _SIZE_T_ #define _BSD_SIZE_T_ #define _SIZE_T_DEFINED_ #define _SIZE_T_DEFINED #define _BSD_SIZE_T_DEFINED_ /* Darwin */ #define _SIZE_T_DECLARED /* FreeBSD 5 */ #define __DEFINED_size_t /* musl libc */ #define ___int_size_t_h #define _GCC_SIZE_T #define _SIZET_ #if defined (__FreeBSD__) \ || defined(__DragonFly__) \ || defined(__FreeBSD_kernel__) \ || defined(__VMS__) /* __size_t is a typedef, must not trash it. */ #else #define __size_t #endif #ifndef __SIZE_TYPE__ #define __SIZE_TYPE__ long unsigned int #endif #if !(defined (__GNUG__) && defined (size_t)) typedef __SIZE_TYPE__ size_t; #ifdef __BEOS__ typedef long ssize_t; #endif /* __BEOS__ */ #endif /* !(defined (__GNUG__) && defined (size_t)) */ #endif /* __size_t */ #endif /* _SIZET_ */ #endif /* _GCC_SIZE_T */ #endif /* ___int_size_t_h */ #endif /* __DEFINED_size_t */ #endif /* _SIZE_T_DECLARED */ #endif /* _BSD_SIZE_T_DEFINED_ */ #endif /* _SIZE_T_DEFINED */ #endif /* _SIZE_T_DEFINED_ */ #endif /* _BSD_SIZE_T_ */ #endif /* _SIZE_T_ */ #endif /* __SIZE_T */ #endif /* _T_SIZE */ #endif /* _T_SIZE_ */ #endif /* _SYS_SIZE_T_H */ #endif /* _SIZE_T */ #endif /* __SIZE_T__ */ #endif /* __size_t__ */ #undef __need_size_t #endif /* _STDDEF_H or __need_size_t. */ /* Wide character type. Locale-writers should change this as necessary to be big enough to hold unique values not between 0 and 127, and not (wchar_t) -1, for each defined multibyte character. */ /* Define this type if we are doing the whole job, or if we want this type in particular. */ #if defined (_STDDEF_H) || defined (__need_wchar_t) #ifndef __wchar_t__ /* BeOS */ #ifndef __WCHAR_T__ /* Cray Unicos/Mk */ #ifndef _WCHAR_T #ifndef _T_WCHAR_ #ifndef _T_WCHAR #ifndef __WCHAR_T #ifndef _WCHAR_T_ #ifndef _BSD_WCHAR_T_ #ifndef _BSD_WCHAR_T_DEFINED_ /* Darwin */ #ifndef _BSD_RUNE_T_DEFINED_ /* Darwin */ #ifndef _WCHAR_T_DECLARED /* FreeBSD 5 */ #ifndef __DEFINED_wchar_t /* musl libc */ #ifndef _WCHAR_T_DEFINED_ #ifndef _WCHAR_T_DEFINED #ifndef _WCHAR_T_H #ifndef ___int_wchar_t_h #ifndef __INT_WCHAR_T_H #ifndef _GCC_WCHAR_T #define __wchar_t__ /* BeOS */ #define __WCHAR_T__ /* Cray Unicos/Mk */ #define _WCHAR_T #define _T_WCHAR_ #define _T_WCHAR #define __WCHAR_T #define _WCHAR_T_ #define _BSD_WCHAR_T_ #define _WCHAR_T_DEFINED_ #define _WCHAR_T_DEFINED #define _WCHAR_T_H #define ___int_wchar_t_h #define __INT_WCHAR_T_H #define _GCC_WCHAR_T #define _WCHAR_T_DECLARED #define __DEFINED_wchar_t /* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_ instead of _WCHAR_T_, and _BSD_RUNE_T_ (which, unlike the other symbols in the _FOO_T_ family, stays defined even after its corresponding type is defined). If we define wchar_t, then we must undef _WCHAR_T_; for BSD/386 1.1 (and perhaps others), if we undef _WCHAR_T_, then we must also define rune_t, since headers like runetype.h assume that if machine/ansi.h is included, and _BSD_WCHAR_T_ is not defined, then rune_t is available. machine/ansi.h says, "Note that _WCHAR_T_ and _RUNE_T_ must be of the same type." */ #ifdef _BSD_WCHAR_T_ #undef _BSD_WCHAR_T_ #ifdef _BSD_RUNE_T_ #if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE) typedef _BSD_RUNE_T_ rune_t; #define _BSD_WCHAR_T_DEFINED_ #define _BSD_RUNE_T_DEFINED_ /* Darwin */ #if defined (__FreeBSD__) && (__FreeBSD__ < 5) /* Why is this file so hard to maintain properly? In contrast to the comment above regarding BSD/386 1.1, on FreeBSD for as long as the symbol has existed, _BSD_RUNE_T_ must not stay defined or redundant typedefs will occur when stdlib.h is included after this file. */ #undef _BSD_RUNE_T_ #endif #endif #endif #endif /* FreeBSD 5 can't be handled well using "traditional" logic above since it no longer defines _BSD_RUNE_T_ yet still desires to export rune_t in some cases... */ #if defined (__FreeBSD__) && (__FreeBSD__ >= 5) #if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE) #if __BSD_VISIBLE #ifndef _RUNE_T_DECLARED typedef __rune_t rune_t; #define _RUNE_T_DECLARED #endif #endif #endif #endif #ifndef __WCHAR_TYPE__ #define __WCHAR_TYPE__ int #endif #ifndef __cplusplus typedef __WCHAR_TYPE__ wchar_t; #endif #endif #endif #endif #endif #endif #endif #endif /* __DEFINED_wchar_t */ #endif /* _WCHAR_T_DECLARED */ #endif /* _BSD_RUNE_T_DEFINED_ */ #endif #endif #endif #endif #endif #endif #endif #endif /* __WCHAR_T__ */ #endif /* __wchar_t__ */ #undef __need_wchar_t #endif /* _STDDEF_H or __need_wchar_t. */ #if defined (__need_wint_t) #ifndef _WINT_T #define _WINT_T #ifndef __WINT_TYPE__ #define __WINT_TYPE__ unsigned int #endif typedef __WINT_TYPE__ wint_t; #endif #undef __need_wint_t #endif #if defined(__NetBSD__) /* The references to _GCC_PTRDIFF_T_, _GCC_SIZE_T_, and _GCC_WCHAR_T_ are probably typos and should be removed before 2.8 is released. */ #ifdef _GCC_PTRDIFF_T_ #undef _PTRDIFF_T_ #undef _BSD_PTRDIFF_T_ #endif #ifdef _GCC_SIZE_T_ #undef _SIZE_T_ #undef _BSD_SIZE_T_ #endif #ifdef _GCC_WCHAR_T_ #undef _WCHAR_T_ #undef _BSD_WCHAR_T_ #endif /* The following ones are the real ones. */ #ifdef _GCC_PTRDIFF_T #undef _PTRDIFF_T_ #undef _BSD_PTRDIFF_T_ #endif #ifdef _GCC_SIZE_T #undef _SIZE_T_ #undef _BSD_SIZE_T_ #endif #ifdef _GCC_WCHAR_T #undef _WCHAR_T_ #undef _BSD_WCHAR_T_ #endif #endif /* __NetBSD__ */ #endif /* __sys_stdtypes_h */ /* A null pointer constant. */ #if defined (_STDDEF_H) || defined (__need_NULL) #undef NULL /* in case <stdio.h> has defined it. */ #ifdef __GNUG__ #define NULL __null #else /* G++ */ #ifndef __cplusplus #define NULL ((void *)0) #else /* C++ */ #define NULL 0 #endif /* C++ */ #endif /* G++ */ #endif /* NULL not defined and <stddef.h> or need NULL. */ #undef __need_NULL #ifdef _STDDEF_H /* Offset of member MEMBER in a struct of type TYPE. */ #undef offsetof /* in case a system header has defined it. */ #define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER) #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) \ || (defined(__cplusplus) && __cplusplus >= 201103L) #ifndef _GCC_MAX_ALIGN_T #define _GCC_MAX_ALIGN_T /* Type whose alignment is supported in every context and is at least as great as that of any standard type not using alignment specifiers. */ typedef struct { long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); /* _Float128 is defined as a basic type, so max_align_t must be sufficiently aligned for it. This code must work in C++, so we use __float128 here; that is only available on some architectures, but only on i386 is extra alignment needed for __float128. */ #ifdef __i386__ __float128 __max_align_f128 __attribute__((__aligned__(__alignof(__float128)))); #endif } max_align_t; #endif #endif /* C11 or C++11. */ #if defined(__cplusplus) && __cplusplus >= 201103L #ifndef _GXX_NULLPTR_T #define _GXX_NULLPTR_T typedef decltype(nullptr) nullptr_t; #endif #endif /* C++11. */ #if defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L #ifndef _GCC_NULLPTR_T #define _GCC_NULLPTR_T typedef __typeof__(nullptr) nullptr_t; #endif #ifndef __STDC_VERSION_STDDEF_H__ #define unreachable() (__builtin_unreachable ()) #define __STDC_VERSION_STDDEF_H__ 202311L #endif #endif /* C23. */ #endif /* _STDDEF_H was defined this time */ #endif /* !_STDDEF_H && !_STDDEF_H_ && !_ANSI_STDDEF_H && !__STDDEF_H__ || __need_XXX was not defined before */ #define __need___va_list // TR1 stdarg.h -*- C++ -*- // Copyright (C) 2006-2025 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 tr1/stdarg.h * This is a TR1 C++ Library header. */ #ifndef _TR1_STDARG_H #define _TR1_STDARG_H 1 // Predefined symbols and macros -*- C++ -*- // Copyright (C) 1997-2025 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 #ifdef _GLIBCXX_SYSHDR #pragma GCC system_header #endif #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wvariadic-macros" #if __cplusplus #endif // The major release number for the GCC release the C++ library belongs to. #define _GLIBCXX_RELEASE // The datestamp of the C++ library in compressed ISO date format. #undef __GLIBCXX__ /* The testsuite defines it to 99999999 to block PCH. */ #define __GLIBCXX__ // 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 # 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 ) // _GLIBCXX14_DEPRECATED // _GLIBCXX14_DEPRECATED_SUGGEST( string-literal ) // _GLIBCXX17_DEPRECATED // _GLIBCXX17_DEPRECATED_SUGGEST( string-literal ) // _GLIBCXX20_DEPRECATED // _GLIBCXX20_DEPRECATED_SUGGEST( string-literal ) // _GLIBCXX23_DEPRECATED // _GLIBCXX23_DEPRECATED_SUGGEST( string-literal ) // _GLIBCXX26_DEPRECATED // _GLIBCXX26_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 >= 201402L) # define _GLIBCXX14_DEPRECATED _GLIBCXX_DEPRECATED # define _GLIBCXX14_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) #else # define _GLIBCXX14_DEPRECATED # define _GLIBCXX14_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 >= 202002L) # define _GLIBCXX20_DEPRECATED [[__deprecated__]] # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) #else # define _GLIBCXX20_DEPRECATED # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) #endif #if defined(__DEPRECATED) && (__cplusplus >= 202100L) # define _GLIBCXX23_DEPRECATED [[__deprecated__]] # define _GLIBCXX23_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) #else # define _GLIBCXX23_DEPRECATED # define _GLIBCXX23_DEPRECATED_SUGGEST(ALT) #endif #if defined(__DEPRECATED) && (__cplusplus >= 202400L) # define _GLIBCXX26_DEPRECATED [[__deprecated__]] # define _GLIBCXX26_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) #else # define _GLIBCXX26_DEPRECATED # define _GLIBCXX26_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 >= 201103L # 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 >= 202002L # define _GLIBCXX20_CONSTEXPR constexpr # else # define _GLIBCXX20_CONSTEXPR # endif #endif #ifndef _GLIBCXX23_CONSTEXPR # if __cplusplus >= 202100L # define _GLIBCXX23_CONSTEXPR constexpr # else # define _GLIBCXX23_CONSTEXPR # endif #endif #ifndef _GLIBCXX26_CONSTEXPR # if __cplusplus >= 202400L # define _GLIBCXX26_CONSTEXPR constexpr # else # define _GLIBCXX26_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(), (void)(_EXC)) # 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 #if __cpp_auto_cast # define _GLIBCXX_AUTO_CAST(X) auto(X) #else # define _GLIBCXX_AUTO_CAST(X) ::std::__decay_t<decltype((X))>(X) #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 /* 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 #pragma GCC visibility push(default) // This allows the library to terminate without including all of <exception> // and without making the declaration of std::terminate visible to users. extern "C++" __attribute__ ((__noreturn__, __always_inline__)) inline void __terminate() _GLIBCXX_USE_NOEXCEPT { void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__,__cold__)); terminate(); } #pragma GCC visibility pop } #define _GLIBCXX_USE_DUAL_ABI # undef _GLIBCXX_USE_CXX11_ABI #endif #ifndef _GLIBCXX_USE_CXX11_ABI #define _GLIBCXX_USE_CXX11_ABI #endif 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 // Non-zero if inline namespaces are used for versioning the entire library. #define _GLIBCXX_INLINE_VERSION // Inline namespace for symbol versioning of (nearly) everything in std. # define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 { # define _GLIBCXX_END_NAMESPACE_VERSION } // Unused when everything in std is versioned anyway. # define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X) # define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X) 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 // Unused. # define _GLIBCXX_BEGIN_NAMESPACE_VERSION # define _GLIBCXX_END_NAMESPACE_VERSION // Used to version individual components, e.g. std::_V2::error_category. # define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X) inline namespace X { # define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X) } // inline namespace X #endif // In the case that we don't have a hosted environment, we can't provide the // debugging mode. Instead, we do our best and downgrade to assertions. #if defined(_GLIBCXX_DEBUG) && !__STDC_HOSTED__ #undef _GLIBCXX_DEBUG #define _GLIBCXX_ASSERTIONS 1 #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 // Use an alternate macro to test for clang, so as to provide an easy // workaround for systems (such as vxworks) whose headers require // __clang__ to be defined, even when compiling with GCC. #if !defined _GLIBCXX_CLANG && defined __clang__ # define _GLIBCXX_CLANG __clang__ // Turn -D_GLIBCXX_CLANG=0 into -U_GLIBCXX_CLANG, so that // _GLIBCXX_CLANG can be tested as defined, just like __clang__. #elif !_GLIBCXX_CLANG # undef _GLIBCXX_CLANG #endif // Define if compatibility should be provided for alternative 128-bit long // double formats. Not possible for Clang until __ibm128 is supported. #ifndef _GLIBCXX_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 #endif // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128 namespace std { #pragma GCC visibility push(default) // Internal version of std::is_constant_evaluated(). // This can be used without checking if the compiler supports the feature. // The macro _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED can be used to check if // the compiler support is present to make this function work as expected. __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR inline bool __is_constant_evaluated() _GLIBCXX_NOEXCEPT { #if __cpp_if_consteval >= 202106L # define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1 if consteval { return true; } else { return false; } #elif __cplusplus >= 201103L && __has_builtin(__builtin_is_constant_evaluated) # define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1 return __builtin_is_constant_evaluated(); #else return false; #endif } #pragma GCC visibility pop } #ifndef _GLIBCXX_ASSERTIONS # if defined(_GLIBCXX_DEBUG) // Debug Mode implies checking assertions. # define _GLIBCXX_ASSERTIONS 1 # elif ! defined(__OPTIMIZE__) && ! defined(_GLIBCXX_NO_ASSERTIONS) // Enable assertions for unoptimized builds. # define _GLIBCXX_ASSERTIONS 1 # endif #endif // Disable std::string explicit instantiation declarations in order to assert. #ifdef _GLIBCXX_ASSERTIONS # undef _GLIBCXX_EXTERN_TEMPLATE # define _GLIBCXX_EXTERN_TEMPLATE -1 #endif #undef _GLIBCXX_VERBOSE_ASSERT // Assert. #ifdef _GLIBCXX_VERBOSE_ASSERT namespace std { #pragma GCC visibility push(default) // Don't use <cassert> because this should be unaffected by NDEBUG. extern "C++" _GLIBCXX_NORETURN __attribute__((__cold__)) void __glibcxx_assert_fail /* Called when a precondition violation is detected. */ (const char* __file, int __line, const char* __function, const char* __condition) _GLIBCXX_NOEXCEPT; #pragma GCC visibility pop } # define _GLIBCXX_ASSERT_FAIL(_Condition) \ std::__glibcxx_assert_fail(__FILE__, __LINE__, __PRETTY_FUNCTION__, \ #_Condition) #else // ! VERBOSE_ASSERT # define _GLIBCXX_ASSERT_FAIL(_Condition) __builtin_abort() #endif #if defined(_GLIBCXX_ASSERTIONS) // When _GLIBCXX_ASSERTIONS is defined we enable runtime assertion checks. // These checks will also be done during constant evaluation. # define __glibcxx_assert(cond) \ do { \ if (__builtin_expect(!bool(cond), false)) \ _GLIBCXX_ASSERT_FAIL(cond); \ } while (false) #elif _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED // _GLIBCXX_ASSERTIONS is not defined, so assertions checks are only enabled // during constant evaluation. This ensures we diagnose undefined behaviour // in constant expressions. namespace std { __attribute__((__always_inline__,__visibility__("default"))) inline void __glibcxx_assert_fail() { } } # define __glibcxx_assert(cond) \ do { \ if (std::__is_constant_evaluated() && !bool(cond)) \ std::__glibcxx_assert_fail(); \ } while (false) #else // _GLIBCXX_ASSERTIONS is not defined and __is_constant_evaluated() doesn't // work so don't check any assertions. # define __glibcxx_assert(cond) #endif // Macro indicating that TSAN is in use. #if __SANITIZE_THREAD__ # define _GLIBCXX_TSAN 1 #elif defined __has_feature # if __has_feature(thread_sanitizer) # define _GLIBCXX_TSAN 1 # endif #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 #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 // First includes. // Pick up any OS-specific definitions. // Specific definitions for newlib -*- C++ -*- // Copyright (C) 2000-2014 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. #ifdef __CYGWIN__ #define _GLIBCXX_GTHREAD_USE_WEAK 0 #if defined (_GLIBCXX_DLL) #define _GLIBCXX_PSEUDO_VISIBILITY_default __attribute__ ((__dllimport__)) #else #define _GLIBCXX_PSEUDO_VISIBILITY_default #endif #define _GLIBCXX_PSEUDO_VISIBILITY_hidden #define _GLIBCXX_PSEUDO_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY_ ## V // See libstdc++/20806. #define _GLIBCXX_HAVE_DOS_BASED_FILESYSTEM 1 #endif #endif // Pick up any CPU-specific definitions. // Specific definitions for generic platforms -*- C++ -*- // Copyright (C) 2005-2014 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 // 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 > 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 # endif #endif #if __FLT_MANT_DIG__ == 24 \ && __FLT_MIN_EXP__ == -125 \ && __FLT_MAX_EXP__ == 128 // Define if float has the IEEE binary32 format. # define _GLIBCXX_FLOAT_IS_IEEE_BINARY32 1 #endif #if __DBL_MANT_DIG__ == 53 \ && __DBL_MIN_EXP__ == -1021 \ && __DBL_MAX_EXP__ == 1024 // Define if double has the IEEE binary64 format. # define _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 1 #elif __FLT_MANT_DIG__ == 24 \ && __FLT_MIN_EXP__ == -125 \ && __FLT_MAX_EXP__ == 128 // Define if double has the IEEE binary32 format. # define _GLIBCXX_DOUBLE_IS_IEEE_BINARY32 1 #endif #if __LDBL_MANT_DIG__ == 113 \ && __LDBL_MIN_EXP__ == -16381 \ && __LDBL_MAX_EXP__ == 16384 // Define if long double has the IEEE binary128 format. # define _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128 1 #elif __LDBL_MANT_DIG__ == 53 \ && __LDBL_MIN_EXP__ == -1021 \ && __LDBL_MAX_EXP__ == 1024 // Define if long double has the IEEE binary64 format. # define _GLIBCXX_LDOUBLE_IS_IEEE_BINARY64 1 #elif __LDBL_MANT_DIG__ == 24 \ && __LDBL_MIN_EXP__ == -125 \ && __LDBL_MAX_EXP__ == 128 // Define if long double has the IEEE binary32 format. # define _GLIBCXX_LDOUBLE_IS_IEEE_BINARY32 1 #endif #if defined __cplusplus && defined __BFLT16_DIG__ namespace __gnu_cxx { typedef __decltype(0.0bf16) __bfloat16_t; } #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_launder) # define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1 #endif // Returns 1 if _GLIBCXX_DO_NOT_USE_BUILTIN_TRAITS is not defined and the // compiler has a corresponding built-in type trait, 0 otherwise. // _GLIBCXX_DO_NOT_USE_BUILTIN_TRAITS can be defined to disable the use of // built-in traits. #ifndef _GLIBCXX_DO_NOT_USE_BUILTIN_TRAITS # define _GLIBCXX_USE_BUILTIN_TRAIT(BT) _GLIBCXX_HAS_BUILTIN(BT) #else # define _GLIBCXX_USE_BUILTIN_TRAIT(BT) 0 #endif // Mark code that should be ignored by the compiler, but seen by Doxygen. #define _GLIBCXX_DOXYGEN_ONLY(X) // 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) // -*- C++ -*- //===-- pstl_config.h -----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _PSTL_CONFIG_H #define _PSTL_CONFIG_H // The version is XYYZ, where X is major, YY is minor, and Z is patch (i.e. X.YY.Z) #define _PSTL_VERSION 17000 #define _PSTL_VERSION_MAJOR (_PSTL_VERSION / 1000) #define _PSTL_VERSION_MINOR ((_PSTL_VERSION % 1000) / 10) #define _PSTL_VERSION_PATCH (_PSTL_VERSION % 10) #if !defined(_PSTL_PAR_BACKEND_SERIAL) && !defined(_PSTL_PAR_BACKEND_TBB) && !defined(_PSTL_PAR_BACKEND_OPENMP) # error "A parallel backend must be specified" #endif // Check the user-defined macro for warnings #if defined(PSTL_USAGE_WARNINGS) # undef _PSTL_USAGE_WARNINGS # define _PSTL_USAGE_WARNINGS PSTL_USAGE_WARNINGS // Check the internal macro for warnings #elif !defined(_PSTL_USAGE_WARNINGS) # define _PSTL_USAGE_WARNINGS 0 #endif // Portability "#pragma" definition #ifdef _MSC_VER # define _PSTL_PRAGMA(x) __pragma(x) #else # define _PSTL_PRAGMA(x) _Pragma(# x) #endif #define _PSTL_STRING_AUX(x) #x #define _PSTL_STRING(x) _PSTL_STRING_AUX(x) #define _PSTL_STRING_CONCAT(x, y) x #y #ifdef _PSTL_HIDE_FROM_ABI_PER_TU # define _PSTL_HIDE_FROM_ABI_PUSH \ _Pragma("clang attribute push(__attribute__((internal_linkage)), apply_to=any(function,record))") # define _PSTL_HIDE_FROM_ABI_POP _Pragma("clang attribute pop") #else # define _PSTL_HIDE_FROM_ABI_PUSH /* nothing */ # define _PSTL_HIDE_FROM_ABI_POP /* nothing */ #endif // note that when ICC or Clang is in use, _PSTL_GCC_VERSION might not fully match // the actual GCC version on the system. #define _PSTL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) #if defined(_GLIBCXX_CLANG) // according to clang documentation, version can be vendor specific # define _PSTL_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) #endif // Enable SIMD for compilers that support OpenMP 4.0 #if (defined(_OPENMP) && _OPENMP >= 201307) || \ (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1600) || \ (!defined(__INTEL_COMPILER) && _PSTL_GCC_VERSION >= 40900) || \ defined(_GLIBCXX_CLANG) # define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd) # define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd) # define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM)) #elif !defined(_MSC_VER) //#pragma simd # define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(simd) # define _PSTL_PRAGMA_DECLARE_SIMD # define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(simd reduction(PRM)) #else //no simd # define _PSTL_PRAGMA_SIMD # define _PSTL_PRAGMA_DECLARE_SIMD # define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) #endif //Enable SIMD #if defined(__INTEL_COMPILER) # define _PSTL_PRAGMA_FORCEINLINE _PSTL_PRAGMA(forceinline) #else # define _PSTL_PRAGMA_FORCEINLINE #endif #if (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1900) || \ (!defined(__INTEL_COMPILER) && _PSTL_GCC_VERSION >= 100000) # define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM)) # define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM)) # define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM)) #else # define _PSTL_PRAGMA_SIMD_SCAN(PRM) # define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) # define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) #endif // Should be defined to 1 for environments with a vendor implementation of C++17 execution policies #define _PSTL_CPP17_EXECUTION_POLICIES_PRESENT (_MSC_VER >= 1912 && _MSVC_LANG >= 201703L) || \ (_GLIBCXX_RELEASE >= 9 && __GLIBCXX__ >= 20190503 && __cplusplus >= 201703L) #if (defined(_MSC_VER) && _MSC_VER >= 1900) || \ __cplusplus >= 201300L || \ __cpp_lib_robust_nonmodifying_seq_ops == 201304 # define _PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT #endif #if (defined(_MSC_VER) && _MSC_VER >= 1900) || \ __cplusplus >= 201402L || \ __cpp_lib_make_reverse_iterator == 201402 # define _PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT #endif #if (defined(_MSC_VER) && _MSC_VER >= 1900) || __cplusplus >= 201402L # define _PSTL_CPP14_INTEGER_SEQUENCE_PRESENT #endif #if (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || \ (defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918) || \ __cplusplus >= 201402L # define _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT #endif #if defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1800 # define _PSTL_EARLYEXIT_PRESENT # define _PSTL_MONOTONIC_PRESENT #endif #if (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1900) || \ (!defined(__INTEL_COMPILER) && _PSTL_GCC_VERSION >= 40900) || \ (defined(_OPENMP) && _OPENMP >= 201307) # define _PSTL_UDR_PRESENT #endif #if (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1900 && __INTEL_COMPILER_BUILD_DATE >= 20180626) || \ (!defined(__INTEL_COMPILER) && _PSTL_GCC_VERSION >= 100000) # define _PSTL_UDS_PRESENT #endif #if defined(_PSTL_EARLYEXIT_PRESENT) # define _PSTL_PRAGMA_SIMD_EARLYEXIT _PSTL_PRAGMA(omp simd early_exit) #else # define _PSTL_PRAGMA_SIMD_EARLYEXIT #endif #if defined(_PSTL_MONOTONIC_PRESENT) # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) _PSTL_PRAGMA(omp ordered simd monotonic(PRM)) # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) _PSTL_PRAGMA(omp ordered simd monotonic(PRM1, PRM2)) #else # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) #endif // Declaration of reduction functor, where // NAME - the name of the functor // OP - type of the callable object with the reduction operation // omp_in - refers to the local partial result // omp_out - refers to the final value of the combiner operator // omp_priv - refers to the private copy of the initial value // omp_orig - refers to the original variable to be reduced #define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP) \ _PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig)) #if defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1600 # define _PSTL_PRAGMA_VECTOR_UNALIGNED _PSTL_PRAGMA(vector unaligned) #else # define _PSTL_PRAGMA_VECTOR_UNALIGNED #endif // Check the user-defined macro to use non-temporal stores #if defined(PSTL_USE_NONTEMPORAL_STORES) && (__INTEL_COMPILER >= 1600) # define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED _PSTL_PRAGMA(vector nontemporal) #else # define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED #endif #if defined(_MSC_VER) || defined(__INTEL_COMPILER) // the preprocessors don't type a message location # define _PSTL_PRAGMA_LOCATION __FILE__ ":" _PSTL_STRING(__LINE__) ": [Parallel STL message]: " #else # define _PSTL_PRAGMA_LOCATION " [Parallel STL message]: " #endif #define _PSTL_PRAGMA_MESSAGE_IMPL(x) _PSTL_PRAGMA(message(_PSTL_STRING_CONCAT(_PSTL_PRAGMA_LOCATION, x))) #if _PSTL_USAGE_WARNINGS # define _PSTL_PRAGMA_MESSAGE(x) _PSTL_PRAGMA_MESSAGE_IMPL(x) # define _PSTL_PRAGMA_MESSAGE_POLICIES(x) _PSTL_PRAGMA_MESSAGE_IMPL(x) #else # define _PSTL_PRAGMA_MESSAGE(x) # define _PSTL_PRAGMA_MESSAGE_POLICIES(x) #endif // broken macros #if defined(__INTEL_COMPILER) && __INTEL_COMPILER == 1800 # define _PSTL_ICC_18_OMP_SIMD_BROKEN #endif #endif /* _PSTL_CONFIG_H */ #endif // __has_include #endif // C++17 #pragma GCC diagnostic pop // End of prewritten config; the settings discovered at configure time follow. // -*- C++ -*- forwarding header. // Copyright (C) 1997-2025 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 include/cstdarg * This is a Standard C++ Library file. You should @c \#include this file * in your programs, rather than any of the @a *.h implementation files. * * This is the C++ version of the Standard C Library header @c stdarg.h, * and its contents are (mostly) the same as that header, but are all * contained in the namespace @c std (except for names which are defined * as macros in C). */ // // ISO C++ 14882: 20.4.6 C library // #ifndef _GLIBCXX_CSTDARG #define _GLIBCXX_CSTDARG 1 #ifdef _GLIBCXX_SYSHDR #pragma GCC system_header #endif #undef __need___va_list /* $OpenBSD: stdarg.h,v 1.10 2020/07/21 23:09:00 daniel Exp $ */ /* * Copyright (c) 2003, 2004 Marc espie <espie@openbsd.org> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef _STDARG_H_ #define _STDARG_H_ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Berkeley Software Design, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _SYS_CDEFS_H_ #define _SYS_CDEFS_H_ #if defined(_KERNEL) && defined(_STANDALONE) #error "_KERNEL and _STANDALONE are mutually exclusive" #endif /* * Provide clang-compatible testing macros. All supported versions of gcc (10+) * provide all of these except has_feature and has_extension which are new in * gcc 14. Keep the older ifndefs, though, for non-gcc compilers that may lack * them like tcc and pcc. */ #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_extension #define __has_extension __has_feature #endif #ifndef __has_feature #define __has_feature(x) 0 #endif #ifndef __has_include #define __has_include(x) 0 #endif #ifndef __has_builtin #define __has_builtin(x) 0 #endif #if defined(__cplusplus) #define __BEGIN_DECLS extern "C" { #define __END_DECLS } #else #define __BEGIN_DECLS #define __END_DECLS #endif /* * This code has been put in place to help reduce the addition of * compiler specific defines in FreeBSD code. It helps to aid in * having a compiler-agnostic source tree. */ /* * Macro to test if we're using a specific version of gcc or later. */ #if defined(__GNUC__) #define __GNUC_PREREQ__(ma, mi) \ (__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi)) #else #define __GNUC_PREREQ__(ma, mi) 0 #endif #if defined(__GNUC__) /* * Compiler memory barriers, specific to gcc and clang. */ #define __compiler_membar() __asm __volatile(" " : : : "memory") #define __CC_SUPPORTS___INLINE 1 #define __CC_SUPPORTS_SYMVER 1 #endif /* __GNUC__ */ /* * TinyC pretends to be gcc 9.3. This is generally good enough to support * everything FreeBSD... except for the .symver assembler directive. */ #ifdef __TINYC__ #undef __CC_SUPPORTS_SYMVER #endif /* * The __CONCAT macro is used to concatenate parts of symbol names, e.g. * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo. * The __CONCAT macro is a bit tricky to use if it must work in non-ANSI * mode -- there must be no spaces between its arguments, and for nested * __CONCAT's, all the __CONCAT's must be at the left. __CONCAT can also * concatenate double-quoted strings produced by the __STRING macro, but * this only works with ANSI C. * * __XSTRING is like __STRING, but it expands any macros in its argument * first. It is only available with ANSI C. */ #if defined(__STDC__) || defined(__cplusplus) #define __P(protos) protos /* full-blown ANSI C */ #define __CONCAT1(x,y) x ## y #define __CONCAT(x,y) __CONCAT1(x,y) #define __STRING(x) #x /* stringify without expanding x */ #define __XSTRING(x) __STRING(x) /* expand x, then stringify */ #define __volatile volatile #if defined(__cplusplus) #define __inline inline /* convert to C++ keyword */ #else #if !(defined(__CC_SUPPORTS___INLINE)) #define __inline /* delete GCC keyword */ #endif /* ! __CC_SUPPORTS___INLINE */ #endif /* !__cplusplus */ #else /* !(__STDC__ || __cplusplus) */ #define __P(protos) () /* traditional C preprocessor */ #define __CONCAT(x,y) x/**/y #define __STRING(x) "x" #if !defined(__CC_SUPPORTS___INLINE) /* Just delete these in a K&R environment */ #define __inline #define __volatile #endif /* !__CC_SUPPORTS___INLINE */ #endif /* !(__STDC__ || __cplusplus) */ /* * Compiler-dependent macros to help declare dead (non-returning) and pure (no * side effects) functions, and unused variables. These attributes are supported * by all current compilers, even pcc. */ #define __weak_symbol __attribute__((__weak__)) #define __dead2 __attribute__((__noreturn__)) #define __pure2 __attribute__((__const__)) #define __unused __attribute__((__unused__)) #define __used __attribute__((__used__)) #define __deprecated __attribute__((__deprecated__)) #define __deprecated1(msg) __attribute__((__deprecated__(msg))) #define __packed __attribute__((__packed__)) #define __aligned(x) __attribute__((__aligned__(x))) #define __section(x) __attribute__((__section__(x))) #define __writeonly __unused #define __alloc_size(x) __attribute__((__alloc_size__(x))) #define __alloc_size2(n, x) __attribute__((__alloc_size__(n, x))) #define __alloc_align(x) __attribute__((__alloc_align__(x))) /* * Keywords added in C11. */ #if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L #if !__has_extension(c_alignas) #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ __has_extension(cxx_alignas) #define _Alignas(x) alignas(x) #else /* XXX: Only emulates _Alignas(constant-expression); not _Alignas(type-name). */ #define _Alignas(x) __aligned(x) #endif #endif #if defined(__cplusplus) && __cplusplus >= 201103L #define _Alignof(x) alignof(x) #else #define _Alignof(x) __alignof(x) #endif #if defined(__cplusplus) && __cplusplus >= 201103L #define _Noreturn [[noreturn]] #else #define _Noreturn __dead2 #endif #if !__has_extension(c_static_assert) #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ __has_extension(cxx_static_assert) #define _Static_assert(x, y) static_assert(x, y) #endif #endif #if !__has_extension(c_thread_local) #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ __has_extension(cxx_thread_local) #define _Thread_local thread_local #else #define _Thread_local __thread #endif #endif #endif /* __STDC_VERSION__ || __STDC_VERSION__ < 201112L */ /* * Emulation of C11 _Generic(). Unlike the previously defined C11 * keywords, it is not possible to implement this using exactly the same * syntax. Therefore implement something similar under the name * __generic(). Unlike _Generic(), this macro can only distinguish * between a single type, so it requires nested invocations to * distinguish multiple cases. * * Note that the comma operator is used to force expr to decay in * order to match _Generic(). */ #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \ __has_extension(c_generic_selections) #define __generic(expr, t, yes, no) \ _Generic(expr, t: yes, default: no) #elif !defined(__cplusplus) #define __generic(expr, t, yes, no) \ __builtin_choose_expr(__builtin_types_compatible_p( \ __typeof(((void)0, (expr))), t), yes, no) #endif /* * C99 Static array indices in function parameter declarations. Syntax such as: * void bar(int myArray[static 10]); * is allowed in C99 but not in C++. Define __min_size appropriately so * headers using it can be compiled in either language. Use like this: * void bar(int myArray[__min_size(10)]); */ #if !defined(__cplusplus) && \ (!defined(__STDC_VERSION__) || (__STDC_VERSION__ >= 199901)) #define __min_size(x) static (x) #else #define __min_size(x) (x) #endif #define __malloc_like __attribute__((__malloc__)) #define __pure __attribute__((__pure__)) #define __always_inline __inline __attribute__((__always_inline__)) #define __noinline __attribute__ ((__noinline__)) #define __fastcall __attribute__((__fastcall__)) #define __result_use_check __attribute__((__warn_unused_result__)) #define __returns_twice __attribute__((__returns_twice__)) #define __unreachable() __builtin_unreachable() #if !defined(__STRICT_ANSI__) || __STDC_VERSION__ >= 199901 #define __LONG_LONG_SUPPORTED #endif /* C++11 exposes a load of C99 stuff */ #if defined(__cplusplus) && __cplusplus >= 201103L #define __LONG_LONG_SUPPORTED #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS #endif #ifndef __STDC_CONSTANT_MACROS #define __STDC_CONSTANT_MACROS #endif #endif /* * noexcept keyword added in C++11. */ #if defined(__cplusplus) && __cplusplus >= 201103L #define __noexcept noexcept #define __noexcept_if(__c) noexcept(__c) #else #define __noexcept #define __noexcept_if(__c) #endif /* * nodiscard attribute added in C++17 and C23, but supported by both LLVM and * GCC in earlier language versions, so we use __has_c{,pp}_attribute to test * for it. * * __nodiscard may be used on a function: * __nodiscard int f(); * * or on a struct, union or enum: * struct __nodiscard S{}; * struct S f(); * * or in C++, on an object constructor. */ #if defined(__cplusplus) && defined(__has_cpp_attribute) #if __has_cpp_attribute(nodiscard) #define __nodiscard [[nodiscard]] #endif #elif defined(__STDC_VERSION__) && defined(__has_c_attribute) #if __has_c_attribute(__nodiscard__) #define __nodiscard [[__nodiscard__]] #endif #endif #ifndef __nodiscard /* * LLVM 16 and earlier don't support [[nodiscard]] in C, but they do support * __warn_unused_result__ with the same semantics, so fall back to that. * We can't do this for GCC because the semantics are different. */ #ifdef __clang__ #define __nodiscard __attribute__((__warn_unused_result__)) #else #define __nodiscard #endif #endif /* * We use `__restrict' as a way to define the `restrict' type qualifier * without disturbing older software that is unaware of C99 keywords. * GCC also provides `__restrict' as an extension to support C99-style * restricted pointers in other language modes. */ #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901 #define __restrict restrict #endif /* * All modern compilers have explicit branch prediction so that the CPU back-end * can hint to the processor and also so that code blocks can be reordered such * that the predicted path sees a more linear flow, thus improving cache * behavior, etc. Use sparingly, except in performance critical code where * they make things measurably faster. */ #define __predict_true(exp) __builtin_expect((exp), 1) #define __predict_false(exp) __builtin_expect((exp), 0) #define __null_sentinel __attribute__((__sentinel__)) #define __exported __attribute__((__visibility__("default"))) #define __hidden __attribute__((__visibility__("hidden"))) /* * We define this here since <stddef.h>, <sys/queue.h>, and <sys/types.h> * require it. */ #define __offsetof(type, field) __builtin_offsetof(type, field) #define __rangeof(type, start, end) \ (__offsetof(type, end) - __offsetof(type, start)) /* * Given the pointer x to the member m of the struct s, return * a pointer to the containing structure. When using GCC, we first * assign pointer x to a local variable, to check that its type is * compatible with member m. */ #define __containerof(x, s, m) ({ \ const volatile __typeof(((s *)0)->m) *__x = (x); \ __DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));\ }) /* * Compiler-dependent macros to declare that functions take printf-like * or scanf-like arguments. */ #define __printflike(fmtarg, firstvararg) \ __attribute__((__format__ (__printf__, fmtarg, firstvararg))) #define __scanflike(fmtarg, firstvararg) \ __attribute__((__format__ (__scanf__, fmtarg, firstvararg))) #define __format_arg(fmtarg) __attribute__((__format_arg__ (fmtarg))) #define __strfmonlike(fmtarg, firstvararg) \ __attribute__((__format__ (__strfmon__, fmtarg, firstvararg))) #define __strftimelike(fmtarg, firstvararg) \ __attribute__((__format__ (__strftime__, fmtarg, firstvararg))) /* * Like __printflike, but allows fmtarg to be NULL. FreeBSD invented 'printf0' * for this because older versions of gcc issued warnings for NULL first args. * Clang has always had printf and printf0 as aliases. gcc 11.0 now follows * clang. So now this is an alias for __printflike, or nothing. In the future * _Nullable or _Nonnull will replace this. * XXX Except that doesn't work, so for now revert to printf0 for clang and * the FreeBSD gcc until I can work this out. */ #if defined(__clang__) || (defined(__GNUC__) && defined (__FreeBSD_cc_version)) #define __printf0like(fmtarg, firstvararg) \ __attribute__((__format__ (__printf0__, fmtarg, firstvararg))) #else #define __printf0like(fmtarg, firstvararg) #endif #define __strong_reference(sym,aliassym) \ extern __typeof (sym) aliassym __attribute__ ((__alias__ (#sym))) #ifdef __STDC__ #define __weak_reference(sym,alias) \ __asm__(".weak " #alias); \ __asm__(".equ " #alias ", " #sym) #define __warn_references(sym,msg) \ __asm__(".section .gnu.warning." #sym); \ __asm__(".asciz \"" msg "\""); \ __asm__(".previous") #ifdef __CC_SUPPORTS_SYMVER #define __sym_compat(sym,impl,verid) \ __asm__(".symver " #impl ", " #sym "@" #verid) #define __sym_default(sym,impl,verid) \ __asm__(".symver " #impl ", " #sym "@@@" #verid) #endif #else #define __weak_reference(sym,alias) \ __asm__(".weak alias"); \ __asm__(".equ alias, sym") #define __warn_references(sym,msg) \ __asm__(".section .gnu.warning.sym"); \ __asm__(".asciz \"msg\""); \ __asm__(".previous") #ifdef __CC_SUPPORTS_SYMVER #define __sym_compat(sym,impl,verid) \ __asm__(".symver impl, sym@verid") #define __sym_default(impl,sym,verid) \ __asm__(".symver impl, sym@@@verid") #endif #endif /* __STDC__ */ #define __GLOBL(sym) __asm__(".globl " __XSTRING(sym)) #define __WEAK(sym) __asm__(".weak " __XSTRING(sym)) #define __IDSTRING(name,string) __asm__(".ident\t\"" string "\"") /* * Embed the rcs id of a source file in the resulting library. Note that in * more recent ELF binutils, we use .ident allowing the ID to be stripped. * Usage: */ #ifndef __FBSDID #if !defined(STRIP_FBSDID) #define __FBSDID(s) __IDSTRING(__CONCAT(__rcsid_,__LINE__),s) #else #define __FBSDID(s) struct __hack #endif #endif #ifndef __RCSID #ifndef NO__RCSID #define __RCSID(s) __IDSTRING(__CONCAT(__rcsid_,__LINE__),s) #else #define __RCSID(s) struct __hack #endif #endif #ifndef __RCSID_SOURCE #ifndef NO__RCSID_SOURCE #define __RCSID_SOURCE(s) __IDSTRING(__CONCAT(__rcsid_source_,__LINE__),s) #else #define __RCSID_SOURCE(s) struct __hack #endif #endif #ifndef __SCCSID #ifndef NO__SCCSID #define __SCCSID(s) __IDSTRING(__CONCAT(__sccsid_,__LINE__),s) #else #define __SCCSID(s) struct __hack #endif #endif #ifndef __COPYRIGHT #ifndef NO__COPYRIGHT #define __COPYRIGHT(s) __IDSTRING(__CONCAT(__copyright_,__LINE__),s) #else #define __COPYRIGHT(s) struct __hack #endif #endif #ifndef __DECONST #define __DECONST(type, var) ((type)(__uintptr_t)(const void *)(var)) #endif #ifndef __DEVOLATILE #define __DEVOLATILE(type, var) ((type)(__uintptr_t)(volatile void *)(var)) #endif #ifndef __DEQUALIFY #define __DEQUALIFY(type, var) ((type)(__uintptr_t)(const volatile void *)(var)) #endif #if !defined(_STANDALONE) && !defined(_KERNEL) #define __RENAME(x) __asm(__STRING(x)) #else /* _STANDALONE || _KERNEL */ #define __RENAME(x) no renaming in kernel/standalone environment #endif /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef EVENT2_VISIBILITY_H_INCLUDED_ #define EVENT2_VISIBILITY_H_INCLUDED_ /* event2/event-config.h * * This file was generated by autoconf when libevent was built, and post- * processed by Libevent so that its macros would have a uniform prefix. * * DO NOT EDIT THIS FILE. * * Do not rely on macros in this file existing in later versions. */ #ifndef _EVENT_CONFIG_H_ #define _EVENT_CONFIG_H_ /* config.h. Generated by configure. */ /* config.h.in. Generated from configure.in by autoheader. */ /* Define if libevent should not allow replacing the mm functions */ /* #undef _EVENT_DISABLE_MM_REPLACEMENT */ /* Define if libevent should not be compiled with thread support */ /* #undef _EVENT_DISABLE_THREAD_SUPPORT */ /* Define if clock_gettime is available in libc */ /* #undef _EVENT_DNS_USE_CPU_CLOCK_FOR_ID */ /* Define is no secure id variant is available */ /* #define _EVENT_DNS_USE_GETTIMEOFDAY_FOR_ID 1 */ #define _EVENT_DNS_USE_FTIME_FOR_ID 1 /* Define to 1 if you have the <arpa/inet.h> header file. */ /* #undef _EVENT_HAVE_ARPA_INET_H */ /* Define to 1 if you have the `clock_gettime' function. */ /* #undef _EVENT_HAVE_CLOCK_GETTIME */ /* Define if /dev/poll is available */ /* #undef _EVENT_HAVE_DEVPOLL */ /* Define to 1 if you have the <dlfcn.h> header file. */ /* #undef _EVENT_HAVE_DLFCN_H */ /* Define if your system supports the epoll system calls */ /* #undef _EVENT_HAVE_EPOLL */ /* Define to 1 if you have the `epoll_ctl' function. */ /* #undef _EVENT_HAVE_EPOLL_CTL */ /* Define to 1 if you have the `eventfd' function. */ /* #undef _EVENT_HAVE_EVENTFD */ /* Define if your system supports event ports */ /* #undef _EVENT_HAVE_EVENT_PORTS */ /* Define to 1 if you have the `fcntl' function. */ /* #undef _EVENT_HAVE_FCNTL */ /* Define to 1 if you have the <fcntl.h> header file. */ #define _EVENT_HAVE_FCNTL_H 1 /* Define to 1 if you have the `getaddrinfo' function. */ #define _EVENT_HAVE_GETADDRINFO 1 /* Define to 1 if you have the `getnameinfo' function. */ #define _EVENT_HAVE_GETNAMEINFO 1 /* Define to 1 if you have the `getprotobynumber' function. */ #define _EVENT_HAVE_GETPROTOBYNUMBER 1 /* Define to 1 if you have the `getservbyname' function. */ #define _EVENT_HAVE_GETSERVBYNAME 1 /* Define to 1 if you have the `gettimeofday' function. */ /* #define _EVENT_HAVE_GETTIMEOFDAY 1 */ /* Define to 1 if you have the `inet_aton' function. */ /* #undef _EVENT_HAVE_INET_ATON */ /* Define to 1 if you have the `inet_ntop' function. */ /* #undef _EVENT_HAVE_INET_NTOP */ /* Define to 1 if you have the `inet_pton' function. */ /* #undef _EVENT_HAVE_INET_PTON */ /* Define to 1 if you have the <inttypes.h> header file. */ /* #define _EVENT_HAVE_INTTYPES_H 1 */ /* Define to 1 if you have the `kqueue' function. */ /* #undef _EVENT_HAVE_KQUEUE */ /* Define if the system has zlib */ /* #undef _EVENT_HAVE_LIBZ */ /* Define to 1 if you have the <memory.h> header file. */ #define _EVENT_HAVE_MEMORY_H 1 /* Define to 1 if you have the `mmap' function. */ /* #undef _EVENT_HAVE_MMAP */ /* Define to 1 if you have the <netinet/in6.h> header file. */ /* #undef _EVENT_HAVE_NETINET_IN6_H */ /* Define to 1 if you have the <netinet/in.h> header file. */ /* #undef _EVENT_HAVE_NETINET_IN_H */ /* Define to 1 if you have the `pipe' function. */ /* #undef _EVENT_HAVE_PIPE */ /* Define to 1 if you have the `poll' function. */ /* #undef _EVENT_HAVE_POLL */ /* Define to 1 if you have the <poll.h> header file. */ /* #undef _EVENT_HAVE_POLL_H */ /* Define to 1 if you have the `port_create' function. */ /* #undef _EVENT_HAVE_PORT_CREATE */ /* Define to 1 if you have the <port.h> header file. */ /* #undef _EVENT_HAVE_PORT_H */ /* Define if you have POSIX threads libraries and header files. */ /* #undef _EVENT_HAVE_PTHREAD */ /* Define if we have pthreads on this system */ /* #undef _EVENT_HAVE_PTHREADS */ /* Define to 1 if the system has the type `sa_family_t'. */ /* #undef _EVENT_HAVE_SA_FAMILY_T */ /* Define to 1 if you have the `select' function. */ /* #undef _EVENT_HAVE_SELECT */ /* Define to 1 if you have the `sendfile' function. */ /* #undef _EVENT_HAVE_SENDFILE */ /* Define if F_SETFD is defined in <fcntl.h> */ /* #undef _EVENT_HAVE_SETFD */ /* Define to 1 if you have the `sigaction' function. */ /* #undef _EVENT_HAVE_SIGACTION */ /* Define to 1 if you have the `signal' function. */ #define _EVENT_HAVE_SIGNAL 1 /* Define to 1 if you have the `splice' function. */ /* #undef _EVENT_HAVE_SPLICE */ /* Define to 1 if you have the <stdarg.h> header file. */ #define _EVENT_HAVE_STDARG_H 1 /* Define to 1 if you have the <stddef.h> header file. */ #define _EVENT_HAVE_STDDEF_H 1 /* Define to 1 if you have the <stdint.h> header file. */ /* #define _EVENT_HAVE_STDINT_H 1 */ /* Define to 1 if you have the <stdlib.h> header file. */ #define _EVENT_HAVE_STDLIB_H 1 /* Define to 1 if you have the <strings.h> header file. */ #define _EVENT_HAVE_STRINGS_H 1 /* Define to 1 if you have the <string.h> header file. */ #define _EVENT_HAVE_STRING_H 1 /* Define to 1 if you have the `strlcpy' function. */ /* #undef _EVENT_HAVE_STRLCPY */ /* Define to 1 if you have the `strsep' function. */ /* #undef _EVENT_HAVE_STRSEP */ /* Define to 1 if you have the `strtok_r' function. */ /* #undef _EVENT_HAVE_STRTOK_R */ /* Define to 1 if you have the `strtoll' function. */ /* #define _EVENT_HAVE_STRTOLL 1 */ #define _EVENT_HAVE_STRUCT_ADDRINFO 1 /* Define to 1 if the system has the type `struct in6_addr'. */ #define _EVENT_HAVE_STRUCT_IN6_ADDR 1 /* Define to 1 if `s6_addr16' is member of `struct in6_addr'. */ #define _EVENT_HAVE_STRUCT_IN6_ADDR_S6_ADDR16 1 /* Define to 1 if `s6_addr32' is member of `struct in6_addr'. */ #define _EVENT_HAVE_STRUCT_IN6_ADDR_S6_ADDR32 1 /* Define to 1 if the system has the type `struct sockaddr_in6'. */ #define _EVENT_HAVE_STRUCT_SOCKADDR_IN6 1 /* Define to 1 if `sin6_len' is member of `struct sockaddr_in6'. */ /* #undef _EVENT_HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN */ /* Define to 1 if `sin_len' is member of `struct sockaddr_in'. */ /* #undef _EVENT_HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */ /* Define to 1 if the system has the type `struct sockaddr_storage'. */ #define _EVENT_HAVE_STRUCT_SOCKADDR_STORAGE 1 /* Define to 1 if you have the <sys/devpoll.h> header file. */ /* #undef _EVENT_HAVE_SYS_DEVPOLL_H */ /* Define to 1 if you have the <sys/epoll.h> header file. */ /* #undef _EVENT_HAVE_SYS_EPOLL_H */ /* Define to 1 if you have the <sys/eventfd.h> header file. */ /* #undef _EVENT_HAVE_SYS_EVENTFD_H */ /* Define to 1 if you have the <sys/event.h> header file. */ /* #undef _EVENT_HAVE_SYS_EVENT_H */ /* Define to 1 if you have the <sys/ioctl.h> header file. */ /* #undef _EVENT_HAVE_SYS_IOCTL_H */ /* Define to 1 if you have the <sys/mman.h> header file. */ /* #undef _EVENT_HAVE_SYS_MMAN_H */ /* Define to 1 if you have the <sys/param.h> header file. */ /* #define _EVENT_HAVE_SYS_PARAM_H 1 */ /* Define to 1 if you have the <sys/queue.h> header file. */ /* #undef _EVENT_HAVE_SYS_QUEUE_H */ /* Define to 1 if you have the <sys/select.h> header file. */ /* #undef _EVENT_HAVE_SYS_SELECT_H */ /* Define to 1 if you have the <sys/sendfile.h> header file. */ /* #undef _EVENT_HAVE_SYS_SENDFILE_H */ /* Define to 1 if you have the <sys/socket.h> header file. */ /* #undef _EVENT_HAVE_SYS_SOCKET_H */ /* Define to 1 if you have the <sys/stat.h> header file. */ #define _EVENT_HAVE_SYS_STAT_H 1 /* Define to 1 if you have the <sys/time.h> header file. */ /* #define _EVENT_HAVE_SYS_TIME_H 1 */ /* Define to 1 if you have the <sys/types.h> header file. */ #define _EVENT_HAVE_SYS_TYPES_H 1 /* Define to 1 if you have the <sys/uio.h> header file. */ /* #undef _EVENT_HAVE_SYS_UIO_H */ /* Define if TAILQ_FOREACH is defined in <sys/queue.h> */ /* #undef _EVENT_HAVE_TAILQFOREACH */ /* Define if timeradd is defined in <sys/time.h> */ /* #undef _EVENT_HAVE_TIMERADD */ /* Define if timerclear is defined in <sys/time.h> */ #define _EVENT_HAVE_TIMERCLEAR 1 /* Define if timercmp is defined in <sys/time.h> */ #define _EVENT_HAVE_TIMERCMP 1 /* Define if timerisset is defined in <sys/time.h> */ #define _EVENT_HAVE_TIMERISSET 1 /* Define to 1 if the system has the type `uint16_t'. */ /* #define _EVENT_HAVE_UINT16_T 1 */ /* Define to 1 if the system has the type `uint32_t'. */ /* #define _EVENT_HAVE_UINT32_T 1 */ /* Define to 1 if the system has the type `uint64_t'. */ /* #define _EVENT_HAVE_UINT64_T 1 */ /* Define to 1 if the system has the type `uint8_t'. */ /* #define _EVENT_HAVE_UINT8_T 1 */ /* Define to 1 if you have the <unistd.h> header file. */ /* #define _EVENT_HAVE_UNISTD_H 1 */ /* Define to 1 if you have the `vasprintf' function. */ /* #undef _EVENT_HAVE_VASPRINTF */ /* Define if kqueue works correctly with pipes */ /* #undef _EVENT_HAVE_WORKING_KQUEUE */ /* Numeric representation of the version */ #define _EVENT_NUMERIC_VERSION 0x02001500 /* Name of package */ #define _EVENT_PACKAGE "libevent" /* Define to the address where bug reports for this package should be sent. */ #define _EVENT_PACKAGE_BUGREPORT "" /* Define to the full name of this package. */ #define _EVENT_PACKAGE_NAME "" /* Define to the full name and version of this package. */ #define _EVENT_PACKAGE_STRING "" /* Define to the one symbol short name of this package. */ #define _EVENT_PACKAGE_TARNAME "" /* Define to the version of this package. */ #define _EVENT_PACKAGE_VERSION "" /* Define to necessary symbol if this constant uses a non-standard name on your system. */ /* #undef _EVENT_PTHREAD_CREATE_JOINABLE */ /* The size of a `int', as computed by sizeof. */ #define _EVENT_SIZEOF_INT 4 /* The size of a `long', as computed by sizeof. */ #define _EVENT_SIZEOF_LONG 4 /* The size of a `long long', as computed by sizeof. */ #define _EVENT_SIZEOF_LONG_LONG 8 /* The size of a `short', as computed by sizeof. */ #define _EVENT_SIZEOF_SHORT 2 /* The size of `size_t', as computed by sizeof. */ #ifdef _WIN64 #define _EVENT_SIZEOF_SIZE_T 8 #else #define _EVENT_SIZEOF_SIZE_T 4 #endif /* The size of `void *', as computed by sizeof. */ #ifdef _WIN64 #define _EVENT_SIZEOF_VOID_P 8 #else #define _EVENT_SIZEOF_VOID_P 4 #endif /* Define to 1 if you have the ANSI C header files. */ #define _EVENT_STDC_HEADERS 1 /* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */ #define _EVENT_TIME_WITH_SYS_TIME 1 /* Version number of package */ #define _EVENT_VERSION "2.0.21-stable" /* Define to appropriate substitue if compiler doesnt have __func__ */ #define _EVENT___func__ __FUNCTION__ /* Define to empty if `const' does not conform to ANSI C. */ /* #undef _EVENT_const */ /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef _EVENT___cplusplus #define _EVENT_inline __inline #endif /* Define to `int' if <sys/types.h> does not define. */ /* #undef _EVENT_pid_t */ /* Define to `unsigned' if <sys/types.h> does not define. */ /* #undef _EVENT_size_t */ /* Define to unsigned int if you dont have it */ #define _EVENT_socklen_t unsigned int /* Define to `int' if <sys/types.h> does not define. */ #define _EVENT_ssize_t SSIZE_T #endif #if defined(event_shared_EXPORTS) || \ defined(event_extra_shared_EXPORTS) || \ defined(event_core_shared_EXPORTS) || \ defined(event_pthreads_shared_EXPORTS) || \ defined(event_openssl_shared_EXPORTS) || \ defined(event_mbedtls_shared_EXPORTS) # if defined (__SUNPRO_C) && (__SUNPRO_C >= 0x550) # define EVENT2_EXPORT_SYMBOL __global # elif defined __GNUC__ # define EVENT2_EXPORT_SYMBOL __attribute__ ((visibility("default"))) # elif defined(_MSC_VER) # define EVENT2_EXPORT_SYMBOL __declspec(dllexport) # else # define EVENT2_EXPORT_SYMBOL /* unknown compiler */ # endif #else /* event_*_EXPORTS */ # define EVENT2_EXPORT_SYMBOL #endif /* event_*_EXPORTS */ /** We need to dllimport event_debug_logging_mask_ into event_extra */ #if defined(_MSC_VER) # if defined(event_core_shared_EXPORTS) /** from core export */ # define EVENT2_CORE_EXPORT_SYMBOL __declspec(dllexport) # elif defined(event_extra_shared_EXPORTS) || /** from extra import */ \ defined(EVENT_VISIBILITY_WANT_DLLIMPORT) # define EVENT2_CORE_EXPORT_SYMBOL __declspec(dllimport) # endif #endif /* _MSC_VER */ #if !defined(EVENT2_CORE_EXPORT_SYMBOL) # define EVENT2_CORE_EXPORT_SYMBOL EVENT2_EXPORT_SYMBOL #endif #endif /* EVENT2_VISIBILITY_H_INCLUDED_ */ /* * Nullability qualifiers: currently only supported by Clang. */ #if !(defined(__clang__) && __has_feature(nullability)) #define _Nonnull #define _Nullable #define _Null_unspecified #define __NULLABILITY_PRAGMA_PUSH #define __NULLABILITY_PRAGMA_POP #else #define __NULLABILITY_PRAGMA_PUSH _Pragma("clang diagnostic push") \ _Pragma("clang diagnostic ignored \"-Wnullability-completeness\"") #define __NULLABILITY_PRAGMA_POP _Pragma("clang diagnostic pop") #endif /* * Type Safety Checking * * Clang provides additional attributes to enable checking type safety * properties that cannot be enforced by the C type system. */ #if __has_attribute(__argument_with_type_tag__) && \ __has_attribute(__type_tag_for_datatype__) #define __arg_type_tag(arg_kind, arg_idx, type_tag_idx) \ __attribute__((__argument_with_type_tag__(arg_kind, arg_idx, type_tag_idx))) #define __datatype_type_tag(kind, type) \ __attribute__((__type_tag_for_datatype__(kind, type))) #else #define __arg_type_tag(arg_kind, arg_idx, type_tag_idx) #define __datatype_type_tag(kind, type) #endif /* * Lock annotations. * * Clang provides support for doing basic thread-safety tests at * compile-time, by marking which locks will/should be held when * entering/leaving a functions. * * Furthermore, it is also possible to annotate variables and structure * members to enforce that they are only accessed when certain locks are * held. */ #if __has_extension(c_thread_safety_attributes) #define __lock_annotate(x) __attribute__((x)) #else #define __lock_annotate(x) #endif /* Structure implements a lock. */ #define __lockable __lock_annotate(lockable) /* Function acquires an exclusive or shared lock. */ #define __locks_exclusive(...) \ __lock_annotate(exclusive_lock_function(__VA_ARGS__)) #define __locks_shared(...) \ __lock_annotate(shared_lock_function(__VA_ARGS__)) /* Function attempts to acquire an exclusive or shared lock. */ #define __trylocks_exclusive(...) \ __lock_annotate(exclusive_trylock_function(__VA_ARGS__)) #define __trylocks_shared(...) \ __lock_annotate(shared_trylock_function(__VA_ARGS__)) /* Function releases a lock. */ #define __unlocks(...) __lock_annotate(unlock_function(__VA_ARGS__)) /* Function asserts that an exclusive or shared lock is held. */ #define __asserts_exclusive(...) \ __lock_annotate(assert_exclusive_lock(__VA_ARGS__)) #define __asserts_shared(...) \ __lock_annotate(assert_shared_lock(__VA_ARGS__)) /* Function requires that an exclusive or shared lock is or is not held. */ #define __requires_exclusive(...) \ __lock_annotate(exclusive_locks_required(__VA_ARGS__)) #define __requires_shared(...) \ __lock_annotate(shared_locks_required(__VA_ARGS__)) #define __requires_unlocked(...) \ __lock_annotate(locks_excluded(__VA_ARGS__)) /* Function should not be analyzed. */ #define __no_lock_analysis __lock_annotate(no_thread_safety_analysis) /* * Function or variable should not be sanitized, e.g., by AddressSanitizer. * GCC has the nosanitize attribute, but as a function attribute only, and * warns on use as a variable attribute. */ #if __has_feature(address_sanitizer) && defined(__clang__) #ifdef _KERNEL #define __nosanitizeaddress __attribute__((no_sanitize("kernel-address"))) #else #define __nosanitizeaddress __attribute__((no_sanitize("address"))) #endif #else #define __nosanitizeaddress #endif #if __has_feature(coverage_sanitizer) && defined(__clang__) #define __nosanitizecoverage __attribute__((no_sanitize("coverage"))) #else #define __nosanitizecoverage #endif #if __has_feature(memory_sanitizer) && defined(__clang__) #ifdef _KERNEL #define __nosanitizememory __attribute__((no_sanitize("kernel-memory"))) #else #define __nosanitizememory __attribute__((no_sanitize("memory"))) #endif #else #define __nosanitizememory #endif #if __has_feature(thread_sanitizer) && defined(__clang__) #define __nosanitizethread __attribute__((no_sanitize("thread"))) #else #define __nosanitizethread #endif /* * Make it possible to opt out of stack smashing protection. */ #if __has_attribute(no_stack_protector) #define __nostackprotector __attribute__((no_stack_protector)) #else #define __nostackprotector \ __attribute__((__optimize__("-fno-stack-protector"))) #endif /* Guard variables and structure members by lock. */ #define __guarded_by(x) __lock_annotate(guarded_by(x)) #define __pt_guarded_by(x) __lock_annotate(pt_guarded_by(x)) /* Alignment builtins for better type checking and improved code generation. */ /* Provide fallback versions for other compilers (GCC/Clang < 10): */ #if !__has_builtin(__builtin_is_aligned) #define __builtin_is_aligned(x, align) \ (((__uintptr_t)(x) & ((align) - 1)) == 0) #endif #if !__has_builtin(__builtin_align_up) #define __builtin_align_up(x, align) \ ((__typeof__(x))(((__uintptr_t)(x)+((align)-1))&(~((align)-1)))) #endif #if !__has_builtin(__builtin_align_down) #define __builtin_align_down(x, align) \ ((__typeof__(x))((x)&(~((align)-1)))) #endif #define __align_up(x, y) __builtin_align_up(x, y) #define __align_down(x, y) __builtin_align_down(x, y) #define __is_aligned(x, y) __builtin_is_aligned(x, y) #endif /* !_SYS_CDEFS_H_ */ /* Define __gnuc_va_list. */ #ifndef __GNUC_VA_LIST #define __GNUC_VA_LIST typedef __builtin_va_list __gnuc_va_list; #endif /* Note that the type used in va_arg is supposed to match the actual type **after default promotions**. Thus, va_arg (..., short) is not valid. */ #define va_start(ap, last) __builtin_va_start((ap), last) #define va_end(ap) __builtin_va_end((ap)) #define va_arg(ap, type) __builtin_va_arg((ap), type) #define __va_copy(dst, src) __builtin_va_copy((dst),(src)) typedef __gnuc_va_list va_list; #if __ISO_C_VISIBLE >= 1999 #define va_copy(dst, src) __va_copy((dst), (src)) #endif #endif /* not _STDARG_H_ */ // Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998 #ifndef va_end #define va_end(ap) va_end (ap) #endif namespace std { using ::va_list; } // namespace std #endif /* * <sys/reent.h> defines __sFILE, _fpos_t. * They must be defined there because struct _reent needs them (and we don't * want reent.h to include this file. */ struct __sFile { int unused; }; typedef struct __sFILE FILE; #define __SLBF 0x0001 /* line buffered */ #define __SNBF 0x0002 /* unbuffered */ #define __SRD 0x0004 /* OK to read */ #define __SWR 0x0008 /* OK to write */ /* RD and WR are never simultaneously asserted */ #define __SRW 0x0010 /* open for reading & writing */ #define __SEOF 0x0020 /* found EOF */ #define __SERR 0x0040 /* found error */ #define __SMBF 0x0080 /* _buf is from malloc */ #define __SAPP 0x0100 /* fdopen()ed in append mode - so must write to end */ #define __SSTR 0x0200 /* this is an sprintf/snprintf string */ #define __SOPT 0x0400 /* do fseek() optimisation */ #define __SNPT 0x0800 /* do not do fseek() optimisation */ #define __SOFF 0x1000 /* set iff _offset is in fact correct */ #define __SMOD 0x2000 /* true => fgetline modified _p text */ #if defined(__CYGWIN__) || defined(__CYGWIN__) #define __SCLE 0x4000 /* convert line endings CR/LF <-> NL */ #endif /* * The following three definitions are for ANSI C, which took them * from System V, which stupidly took internal interface macros and * made them official arguments to setvbuf(), without renaming them. * Hence, these ugly _IOxxx names are *supposed* to appear in user code. * * Although these happen to match their counterparts above, the * implementation does not rely on that (so these could be renumbered). */ #define _IOFBF 0 /* setvbuf should set fully buffered */ #define _IOLBF 1 /* setvbuf should set line buffered */ #define _IONBF 2 /* setvbuf should set unbuffered */ #ifndef NULL #define NULL 0 #endif #define BUFSIZ 1024 #define EOF (-1) #define FOPEN_MAX 20 /* must be <= OPEN_MAX <sys/syslimits.h> */ #define FILENAME_MAX 1024 /* must be <= PATH_MAX <sys/syslimits.h> */ #define L_tmpnam 1024 /* XXX must be == PATH_MAX */ #ifndef __STRICT_ANSI__ #define P_tmpdir "/tmp" #endif #ifndef SEEK_SET #define SEEK_SET 0 /* set file offset to offset */ #endif #ifndef SEEK_CUR #define SEEK_CUR 1 /* set file offset to current plus offset */ #endif #ifndef SEEK_END #define SEEK_END 2 /* set file offset to EOF plus offset */ #endif #define TMP_MAX 26 #define stdin (_impure_ptr->_stdin) #define stdout (_impure_ptr->_stdout) #define stderr (_impure_ptr->_stderr) #define _stdin_r(x) ((x)->_stdin) #define _stdout_r(x) ((x)->_stdout) #define _stderr_r(x) ((x)->_stderr) /* * Functions defined in ANSI C standard. */ #ifdef __GNUC__ #define __VALIST __gnuc_va_list #else #define __VALIST char* #endif #ifndef _EXFUN # define _EXFUN(N,P) N P #endif int _EXFUN(printf, (const char *, ...)); int _EXFUN(scanf, (const char *, ...)); int _EXFUN(sscanf, (const char *, const char *, ...)); int _EXFUN(vfprintf, (FILE *, const char *, __VALIST)); int _EXFUN(vprintf, (const char *, __VALIST)); int _EXFUN(vsprintf, (char *, const char *, __VALIST)); int _EXFUN(vsnprintf, (char *, size_t, const char *, __VALIST)); int _EXFUN(fgetc, (FILE *)); char * _EXFUN(fgets, (char *, int, FILE *)); int _EXFUN(fputc, (int, FILE *)); int _EXFUN(fputs, (const char *, FILE *)); int _EXFUN(getc, (FILE *)); int _EXFUN(getchar, (void)); char * _EXFUN(gets, (char *)); int _EXFUN(putc, (int, FILE *)); int _EXFUN(putchar, (int)); int _EXFUN(puts, (const char *)); int _EXFUN(ungetc, (int, FILE *)); size_t _EXFUN(fread, (void *, size_t _size, size_t _n, FILE *)); size_t _EXFUN(fwrite, (const void *, size_t _size, size_t _n, FILE *)); int _EXFUN(sprintf, (char *, const char *, ...)); int _EXFUN(snprintf, (char *, size_t, const char *, ...)); #ifdef __cplusplus } #endif int main(){ int a,b; scanf("%d %d",&a,&b); printf("%d",a+b); } }}}
