1    	// -*- C++ -*- forwarding header.
2    	
3    	// Copyright (C) 1997-2017 Free Software Foundation, Inc.
4    	//
5    	// This file is part of the GNU ISO C++ Library.  This library is free
6    	// software; you can redistribute it and/or modify it under the
7    	// terms of the GNU General Public License as published by the
8    	// Free Software Foundation; either version 3, or (at your option)
9    	// any later version.
10   	
11   	// This library is distributed in the hope that it will be useful,
12   	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13   	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   	// GNU General Public License for more details.
15   	
16   	// Under Section 7 of GPL version 3, you are granted additional
17   	// permissions described in the GCC Runtime Library Exception, version
18   	// 3.1, as published by the Free Software Foundation.
19   	
20   	// You should have received a copy of the GNU General Public License and
21   	// a copy of the GCC Runtime Library Exception along with this program;
22   	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23   	// <http://www.gnu.org/licenses/>.
24   	
25   	/** @file cstddef
26   	 *  This is a Standard C++ Library file.  You should @c \#include this file
27   	 *  in your programs, rather than any of the @a *.h implementation files.
28   	 *
29   	 *  This is the C++ version of the Standard C Library header @c stddef.h,
30   	 *  and its contents are (mostly) the same as that header, but are all
31   	 *  contained in the namespace @c std (except for names which are defined
32   	 *  as macros in C).
33   	 */
34   	
35   	//
36   	// ISO C++ 14882: 18.1  Types
37   	//
38   	
39   	#ifndef _GLIBCXX_CSTDDEF
40   	#define _GLIBCXX_CSTDDEF 1
41   	
42   	#pragma GCC system_header
43   	
44   	#undef __need_wchar_t
45   	#undef __need_ptrdiff_t
46   	#undef __need_size_t
47   	#undef __need_NULL
48   	#undef __need_wint_t
49   	#include <bits/c++config.h>
50   	#include <stddef.h>
51   	
52   	#if __cplusplus >= 201103L
53   	namespace std
54   	{
55   	  // We handle size_t, ptrdiff_t, and nullptr_t in c++config.h.
56   	  using ::max_align_t;
57   	}
58   	#endif
59   	
60   	#if __cplusplus >= 201703L
61   	namespace std
62   	{
63   	#define __cpp_lib_byte 201603
64   	
65   	  /// std::byte
66   	  enum class byte : unsigned char {};
67   	
68   	  template<typename _IntegerType> struct __byte_operand { };
69   	  template<> struct __byte_operand<bool> { using __type = byte; };
70   	  template<> struct __byte_operand<char> { using __type = byte; };
71   	  template<> struct __byte_operand<signed char> { using __type = byte; };
72   	  template<> struct __byte_operand<unsigned char> { using __type = byte; };
73   	#ifdef _GLIBCXX_USE_WCHAR_T
74   	  template<> struct __byte_operand<wchar_t> { using __type = byte; };
75   	#endif
76   	  template<> struct __byte_operand<char16_t> { using __type = byte; };
77   	  template<> struct __byte_operand<char32_t> { using __type = byte; };
78   	  template<> struct __byte_operand<short> { using __type = byte; };
79   	  template<> struct __byte_operand<unsigned short> { using __type = byte; };
80   	  template<> struct __byte_operand<int> { using __type = byte; };
81   	  template<> struct __byte_operand<unsigned int> { using __type = byte; };
82   	  template<> struct __byte_operand<long> { using __type = byte; };
83   	  template<> struct __byte_operand<unsigned long> { using __type = byte; };
84   	  template<> struct __byte_operand<long long> { using __type = byte; };
85   	  template<> struct __byte_operand<unsigned long long> { using __type = byte; };
86   	#if defined(__GLIBCXX_TYPE_INT_N_0)
87   	  template<> struct __byte_operand<__GLIBCXX_TYPE_INT_N_0>
88   	  { using __type = byte; };
89   	  template<> struct __byte_operand<unsigned __GLIBCXX_TYPE_INT_N_0>
90   	  { using __type = byte; };
91   	#endif
92   	#if defined(__GLIBCXX_TYPE_INT_N_1)
93   	  template<> struct __byte_operand<__GLIBCXX_TYPE_INT_N_1>
94   	  { using __type = byte; };
95   	  template<> struct __byte_operand<unsigned __GLIBCXX_TYPE_INT_N_1>
96   	  { using __type = byte; };
97   	#endif
98   	#if defined(__GLIBCXX_TYPE_INT_N_2)
99   	  template<> struct __byte_operand<__GLIBCXX_TYPE_INT_N_2>
100  	  { using __type = byte; };
101  	  template<> struct __byte_operand<unsigned __GLIBCXX_TYPE_INT_N_2>
102  	  { using __type = byte; };
103  	#endif
104  	  template<typename _IntegerType>
105  	    struct __byte_operand<const _IntegerType>
106  	    : __byte_operand<_IntegerType> { };
107  	  template<typename _IntegerType>
108  	    struct __byte_operand<volatile _IntegerType>
109  	    : __byte_operand<_IntegerType> { };
110  	  template<typename _IntegerType>
111  	    struct __byte_operand<const volatile _IntegerType>
112  	    : __byte_operand<_IntegerType> { };
113  	
114  	  template<typename _IntegerType>
115  	    using __byte_op_t = typename __byte_operand<_IntegerType>::__type;
116  	
117  	  template<typename _IntegerType>
118  	    constexpr __byte_op_t<_IntegerType>&
119  	    operator<<=(byte& __b, _IntegerType __shift) noexcept
120  	    { return __b = byte(static_cast<unsigned char>(__b) << __shift); }
121  	
122  	  template<typename _IntegerType>
123  	    constexpr __byte_op_t<_IntegerType>
124  	    operator<<(byte __b, _IntegerType __shift) noexcept
125  	    { return byte(static_cast<unsigned char>(__b) << __shift); }
126  	
127  	  template<typename _IntegerType>
128  	    constexpr __byte_op_t<_IntegerType>&
129  	    operator>>=(byte& __b, _IntegerType __shift) noexcept
130  	    { return __b = byte(static_cast<unsigned char>(__b) >> __shift); }
131  	
132  	  template<typename _IntegerType>
133  	    constexpr __byte_op_t<_IntegerType>
134  	    operator>>(byte __b, _IntegerType __shift) noexcept
135  	    { return byte(static_cast<unsigned char>(__b) >> __shift); }
136  	
137  	  constexpr byte&
138  	  operator|=(byte& __l, byte __r) noexcept
139  	  {
140  	    return __l =
141  	      byte(static_cast<unsigned char>(__l) | static_cast<unsigned char>(__r));
142  	  }
143  	
144  	  constexpr byte
145  	  operator|(byte __l, byte __r) noexcept
146  	  {
147  	    return
148  	      byte(static_cast<unsigned char>(__l) | static_cast<unsigned char>(__r));
149  	  }
150  	
151  	  constexpr byte&
152  	  operator&=(byte& __l, byte __r) noexcept
153  	  {
154  	   return __l =
155  	     byte(static_cast<unsigned char>(__l) & static_cast<unsigned char>(__r));
156  	  }
157  	
158  	  constexpr byte
159  	  operator&(byte __l, byte __r) noexcept
160  	  {
161  	    return
162  	      byte(static_cast<unsigned char>(__l) & static_cast<unsigned char>(__r));
163  	  }
164  	
165  	  constexpr byte&
166  	  operator^=(byte& __l, byte __r) noexcept
167  	  {
168  	    return __l =
169  	      byte(static_cast<unsigned char>(__l) ^ static_cast<unsigned char>(__r));
170  	  }
171  	
172  	  constexpr byte
173  	  operator^(byte __l, byte __r) noexcept
174  	  {
175  	    return
176  	      byte(static_cast<unsigned char>(__l) ^ static_cast<unsigned char>(__r));
177  	  }
178  	
179  	  constexpr byte
180  	  operator~(byte __b) noexcept
181  	  { return byte(~static_cast<unsigned char>(__b)); }
182  	
183  	  template<typename _IntegerType>
184  	    constexpr _IntegerType
185  	    to_integer(__byte_op_t<_IntegerType> __b) noexcept
186  	    { return _IntegerType(__b); }
187  	
188  	} // namespace std
189  	#endif
190  	
191  	#endif // _GLIBCXX_CSTDDEF
192