feedc0de/boost_config
1
0
Fork 0
forked from boostorg/config
Code Pull Requests Activity

Merge pull request #19 from glenfe/master

Browse Source 
Move cstdint into Boost.Config
This commit is contained in:
jzmaddock
2014-06-01 18:00:59 +01:00
parent 06445cd39c e008ddb971
commit 5493717a9f
40 changed files with 1823 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
doc/config.qbk
View File

@ -50,6 +50,7 @@ Distributed under the Boost Software License, Version 1.0.
[include configuring_boost.qbk]
[include macro_reference.qbk]
[include cstdint.qbk]
[include guidelines.qbk]
[include rationale.qbk]
[include acknowledgements.qbk]

139
doc/cstdint.qbk Normal file
View File

@ -0,0 +1,139 @@
[section:cstdint Standard Integer Types]
[section Overview]
The header [^[@../../../../boost/cstdint.hpp <boost/cstdint.hpp>]] provides the typedef's useful
for writing portable code that requires certain integer widths. All typedef's are in namespace boost.
The specifications for these types are based on the ISO/IEC 9899:1999 C Language standard header <stdint.h>.
The 64-bit types required by the C standard are ['not required] in the boost header,
and may not be supplied for all platforms/compilers, because [^long long] is not [yet] included in the C++ standard.
See [@../../test/cstdint_test.cpp cstdint_test.cpp] for a test program.
[endsect]
[section:rationale Rationale]
The organization of the Boost.Integer headers and classes is designed to take advantage of <stdint.h> types from the
1999 C standard without causing undefined behavior in terms of the 1998 C++ standard.
The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace [^boost]
without placing any names in namespace [^std]. The intension is to complement rather than compete
with the C++ Standard Library. Should some future C++ standard include <stdint.h> and <cstdint>,
then <boost/cstdint.hpp> will continue to function, but will become redundant and may be safely deprecated.
Because these are boost headers, their names conform to boost header naming conventions rather than
C++ Standard Library header naming conventions.
[endsect]
[section:ce ['Caveat emptor]]
As an implementation artifact, certain C <limits.h> macro names may possibly be
visible to users of <boost/cstdint.hpp>. Don't use these macros; they are not part of
any Boost-specified interface. Use [^boost::integer_traits<>] or [^std::numeric_limits<>] instead.
As another implementation artifact, certain C <stdint.h> typedef names may possibly be visible
in the global namespace to users of <boost/cstdint.hpp>. Don't use these names, they are not part of
any Boost-specified interface. Use the respective names in namespace [^boost] instead.
[endsect]
[section Exact-width integer types]
The typedef [^int#_t], with # replaced by the width, designates a signed integer type of exactly # bits;
for example [^int8_t] denotes an 8-bit signed integer type. Similarly, the typedef [^uint#_t] designates an unsigned
integer type of exactly # bits.
These types are optional. However, if a platform supports integer types with widths of
8, 16, 32, 64, or any combination thereof, then <boost/cstdint.hpp> does provide the
corresponding typedefs.
The absence of int64_t and uint64_t is indicated by the macro `BOOST_NO_INT64_T`.
[endsect]
[section Minimum-width integer types]
The typedef [^int_least#_t], with # replaced by the width, designates a signed integer type with a width
of at least # bits, such that no signed integer type with lesser size has at least the specified width.
Thus, [^int_least32_t] denotes the smallest signed integer type with a width of at least 32 bits.
Similarly, the typedef name [^uint_least#_t] designates an unsigned integer type with a width of at least # bits,
such that no unsigned integer type with lesser size has at least the specified width.
The following minimum-width integer types are provided for all platforms:
* [^int_least8_t]
* [^int_least16_t]
* [^int_least32_t]
* [^uint_least8_t]
* [^uint_least16_t]
* [^uint_least32_t]
The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
* [^int_least64_t]
* [^uint_least64_t]
All other minimum-width integer types are optional.
[endsect]
[section Fastest minimum-width integer types]
The typedef [^int_fast#_t], with # replaced by the width, designates the fastest signed integer type
with a width of at least # bits. Similarly, the typedef name [^uint_fast#_t] designates the fastest
unsigned integer type with a width of at least # bits.
There is no guarantee that these types are fastest for all purposes. In any case, however, they satisfy
the signedness and width requirements.
The following fastest minimum-width integer types are provided for all platforms:
* [^int_fast8_t]
* [^int_fast16_t]
* [^int_fast32_t]
* [^uint_fast8_t]
* [^uint_fast16_t]
* [^uint_fast32_t]
The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
* [^int_fast64_t]
* [^uint_fast64_t]
All other fastest minimum-width integer types are optional.
[endsect]
[section Greatest-width integer types]
The typedef [^intmax_t ]designates a signed integer type capable of representing any value of any signed integer type.
The typedef [^uintmax_t] designates an unsigned integer type capable of representing any value of any unsigned integer type.
These types are provided for all platforms.
[endsect]
[section Integer Constant Macros]
The following macros are always defined after inclusion of this header, these allow
integer constants of at least the specified width to be declared:
INT8_C, UINT8_C, INT16_C, UINT16_C, INT32_C, UINT32_C, INTMAX_C, UINTMAX_C.
The macros INT64_C and UINT64_C are also defined if the the macro BOOST_NO_INT64_T is not defined.
The C99 macro __STDC_CONSTANT_MACROS is also defined as an artifact of the implementation.
For example:
#include <boost/cstdint.hpp>
// Here the constant 0x1FFFFFFFF has the correct suffix applied:
static const boost::uint64_t c = INT64_C(0x1FFFFFFFF);
[endsect]
[endsect]

85
doc/html/boost_config/boost_macro_reference.html
View File

@ -7,7 +7,7 @@
<link rel="home" href="../index.html" title="Boost.Config">
<link rel="up" href="../index.html" title="Boost.Config">
<link rel="prev" href="../index.html" title="Boost.Config">
<link rel="next" href="guidelines_for_boost_authors.html" title="Guidelines for Boost Authors">
<link rel="next" href="cstdint.html" title="Standard Integer Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -20,7 +20,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="guidelines_for_boost_authors.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cstdint.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
@ -2377,6 +2377,18 @@
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_NO_CXX11_ADDRESSOF</span></code>
</p>
</td>
<td>
<p>
The standard library header &lt;memory&gt; has no working std::addressof.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_NO_CXX11_ALIGNAS</span></code>
@ -2681,6 +2693,18 @@
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_NO_CXX11_STD_ALIGN</span></code>
</p>
</td>
<td>
<p>
The standard library header &lt;memory&gt; has no working std::align.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_NO_CXX11_AUTO_DECLARATIONS</span></code>
@ -2939,6 +2963,19 @@
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_NO_CXX11_REF_QUALIFIERS</span></code>
</p>
</td>
<td>
<p>
The compiler does not support ref-qualifiers on member functions
as described in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm" target="_top">N2439</a>.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_NO_CXX11_RVALUE_REFERENCES</span></code>
@ -3761,7 +3798,7 @@
<td>
<p>
This macro can be used in place of the <code class="computeroutput"><span class="keyword">inline</span></code>
keyword to instruct the compiler that a function should always
keyword to instruct the compiler that the function should always
be inlined. Overuse of this macro can lead to significant bloat,
while good use can increase performance in certain cases, such
as computation-intensive code built through generative programming
@ -3795,8 +3832,8 @@
<td>
<p>
This macro can be used in place of the <code class="computeroutput"><span class="keyword">inline</span></code>
keyword to instruct the compiler that a function should never be
inlined. One should typically use this macro to mark functions
keyword to instruct the compiler that the function should never
be inlined. One should typically use this macro to mark functions
that are unlikely to be called, such as error handling routines.
</p>
<p>
@ -3812,6 +3849,42 @@
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_NORETURN</span></code>
</p>
</td>
<td>
<p>
This macro can be used before the function declaration or definition
to instruct the compiler that the function does not return normally
(i.e. with a <code class="computeroutput"><span class="keyword">return</span></code>
statement or by leaving the function scope, if the function return
type is <code class="computeroutput"><span class="keyword">void</span></code>). The
macro can be used to mark functions that always throw exceptions
or terminate the application. Compilers that support this markup
may use this information to specifically organize the code surrounding
calls to this function and suppress warnings about missing <code class="computeroutput"><span class="keyword">return</span></code> statements in the functions
enclosing such calls.
</p>
<p>
Usage example:
</p>
<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">BOOST_NORETURN</span> <span class="keyword">void</span> <span class="identifier">on_error_occurred</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">descr</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span><span class="special">(</span><span class="identifier">descr</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
If the compiler does not support this markup, <code class="computeroutput"><span class="identifier">BOOST_NORETURN</span></code>
is defined empty and an additional macro <code class="computeroutput"><span class="identifier">BOOST_NO_NORETURN</span></code>
is defined.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">BOOST_LIKELY</span><span class="special">(</span><span class="identifier">X</span><span class="special">)</span></code>
@ -5540,7 +5613,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="guidelines_for_boost_authors.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cstdint.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

289
doc/html/boost_config/cstdint.html Normal file
View File

@ -0,0 +1,289 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Standard Integer Types</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
<link rel="home" href="../index.html" title="Boost.Config">
<link rel="up" href="../index.html" title="Boost.Config">
<link rel="prev" href="boost_macro_reference.html" title="Boost Macro Reference">
<link rel="next" href="guidelines_for_boost_authors.html" title="Guidelines for Boost Authors">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="boost_macro_reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="guidelines_for_boost_authors.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_config.cstdint"></a><a class="link" href="cstdint.html" title="Standard Integer Types">Standard Integer Types</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.overview">Overview</a></span></dt>
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.rationale">Rationale</a></span></dt>
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.ce"><span class="emphasis"><em>Caveat emptor</em></span></a></span></dt>
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.exact_width_integer_types">Exact-width
integer types</a></span></dt>
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.minimum_width_integer_types">Minimum-width
integer types</a></span></dt>
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.fastest_minimum_width_integer_types">Fastest
minimum-width integer types</a></span></dt>
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.greatest_width_integer_types">Greatest-width
integer types</a></span></dt>
<dt><span class="section"><a href="cstdint.html#boost_config.cstdint.integer_constant_macros">Integer
Constant Macros</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.overview"></a><a class="link" href="cstdint.html#boost_config.cstdint.overview" title="Overview">Overview</a>
</h3></div></div></div>
<p>
The header <code class="literal"><a href="../../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a></code>
provides the typedef's useful for writing portable code that requires certain
integer widths. All typedef's are in namespace boost.
</p>
<p>
The specifications for these types are based on the ISO/IEC 9899:1999 C Language
standard header &lt;stdint.h&gt;. The 64-bit types required by the C standard
are <span class="emphasis"><em>not required</em></span> in the boost header, and may not be
supplied for all platforms/compilers, because <code class="literal">long long</code>
is not [yet] included in the C++ standard.
</p>
<p>
See <a href="../../../test/cstdint_test.cpp" target="_top">cstdint_test.cpp</a> for
a test program.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.rationale"></a><a class="link" href="cstdint.html#boost_config.cstdint.rationale" title="Rationale">Rationale</a>
</h3></div></div></div>
<p>
The organization of the Boost.Integer headers and classes is designed to
take advantage of &lt;stdint.h&gt; types from the 1999 C standard without
causing undefined behavior in terms of the 1998 C++ standard. The header
&lt;boost/cstdint.hpp&gt; makes the standard integer types safely available
in namespace <code class="literal">boost</code> without placing any names in namespace
<code class="literal">std</code>. The intension is to complement rather than compete
with the C++ Standard Library. Should some future C++ standard include &lt;stdint.h&gt;
and &lt;cstdint&gt;, then &lt;boost/cstdint.hpp&gt; will continue to function,
but will become redundant and may be safely deprecated.
</p>
<p>
Because these are boost headers, their names conform to boost header naming
conventions rather than C++ Standard Library header naming conventions.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.ce"></a><a class="link" href="cstdint.html#boost_config.cstdint.ce" title="Caveat emptor"><span class="emphasis"><em>Caveat emptor</em></span></a>
</h3></div></div></div>
<p>
As an implementation artifact, certain C &lt;limits.h&gt; macro names may
possibly be visible to users of &lt;boost/cstdint.hpp&gt;. Don't use these
macros; they are not part of any Boost-specified interface. Use <code class="literal">boost::integer_traits&lt;&gt;</code>
or <code class="literal">std::numeric_limits&lt;&gt;</code> instead.
</p>
<p>
As another implementation artifact, certain C &lt;stdint.h&gt; typedef names
may possibly be visible in the global namespace to users of &lt;boost/cstdint.hpp&gt;.
Don't use these names, they are not part of any Boost-specified interface.
Use the respective names in namespace <code class="literal">boost</code> instead.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.exact_width_integer_types"></a><a class="link" href="cstdint.html#boost_config.cstdint.exact_width_integer_types" title="Exact-width integer types">Exact-width
integer types</a>
</h3></div></div></div>
<p>
The typedef <code class="literal">int#_t</code>, with # replaced by the width, designates
a signed integer type of exactly # bits; for example <code class="literal">int8_t</code>
denotes an 8-bit signed integer type. Similarly, the typedef <code class="literal">uint#_t</code>
designates an unsigned integer type of exactly # bits.
</p>
<p>
These types are optional. However, if a platform supports integer types with
widths of 8, 16, 32, 64, or any combination thereof, then &lt;boost/cstdint.hpp&gt;
does provide the corresponding typedefs.
</p>
<p>
The absence of int64_t and uint64_t is indicated by the macro <code class="computeroutput"><span class="identifier">BOOST_NO_INT64_T</span></code>.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.minimum_width_integer_types"></a><a class="link" href="cstdint.html#boost_config.cstdint.minimum_width_integer_types" title="Minimum-width integer types">Minimum-width
integer types</a>
</h3></div></div></div>
<p>
The typedef <code class="literal">int_least#_t</code>, with # replaced by the width,
designates a signed integer type with a width of at least # bits, such that
no signed integer type with lesser size has at least the specified width.
Thus, <code class="literal">int_least32_t</code> denotes the smallest signed integer
type with a width of at least 32 bits. Similarly, the typedef name <code class="literal">uint_least#_t</code>
designates an unsigned integer type with a width of at least # bits, such
that no unsigned integer type with lesser size has at least the specified
width.
</p>
<p>
The following minimum-width integer types are provided for all platforms:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="literal">int_least8_t</code>
</li>
<li class="listitem">
<code class="literal">int_least16_t</code>
</li>
<li class="listitem">
<code class="literal">int_least32_t</code>
</li>
<li class="listitem">
<code class="literal">uint_least8_t</code>
</li>
<li class="listitem">
<code class="literal">uint_least16_t</code>
</li>
<li class="listitem">
<code class="literal">uint_least32_t</code>
</li>
</ul></div>
<p>
The following types are available only if, after including &lt;boost/cstdint.hpp&gt;,
the macro BOOST_NO_INT64_T is not defined:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="literal">int_least64_t</code>
</li>
<li class="listitem">
<code class="literal">uint_least64_t</code>
</li>
</ul></div>
<p>
All other minimum-width integer types are optional.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.fastest_minimum_width_integer_types"></a><a class="link" href="cstdint.html#boost_config.cstdint.fastest_minimum_width_integer_types" title="Fastest minimum-width integer types">Fastest
minimum-width integer types</a>
</h3></div></div></div>
<p>
The typedef <code class="literal">int_fast#_t</code>, with # replaced by the width,
designates the fastest signed integer type with a width of at least # bits.
Similarly, the typedef name <code class="literal">uint_fast#_t</code> designates the
fastest unsigned integer type with a width of at least # bits.
</p>
<p>
There is no guarantee that these types are fastest for all purposes. In any
case, however, they satisfy the signedness and width requirements.
</p>
<p>
The following fastest minimum-width integer types are provided for all platforms:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="literal">int_fast8_t</code>
</li>
<li class="listitem">
<code class="literal">int_fast16_t</code>
</li>
<li class="listitem">
<code class="literal">int_fast32_t</code>
</li>
<li class="listitem">
<code class="literal">uint_fast8_t</code>
</li>
<li class="listitem">
<code class="literal">uint_fast16_t</code>
</li>
<li class="listitem">
<code class="literal">uint_fast32_t</code>
</li>
</ul></div>
<p>
The following types are available only if, after including &lt;boost/cstdint.hpp&gt;,
the macro BOOST_NO_INT64_T is not defined:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="literal">int_fast64_t</code>
</li>
<li class="listitem">
<code class="literal">uint_fast64_t</code>
</li>
</ul></div>
<p>
All other fastest minimum-width integer types are optional.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.greatest_width_integer_types"></a><a class="link" href="cstdint.html#boost_config.cstdint.greatest_width_integer_types" title="Greatest-width integer types">Greatest-width
integer types</a>
</h3></div></div></div>
<p>
The typedef <code class="literal">intmax_t </code>designates a signed integer type
capable of representing any value of any signed integer type.
</p>
<p>
The typedef <code class="literal">uintmax_t</code> designates an unsigned integer type
capable of representing any value of any unsigned integer type.
</p>
<p>
These types are provided for all platforms.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_config.cstdint.integer_constant_macros"></a><a class="link" href="cstdint.html#boost_config.cstdint.integer_constant_macros" title="Integer Constant Macros">Integer
Constant Macros</a>
</h3></div></div></div>
<p>
The following macros are always defined after inclusion of this header, these
allow integer constants of at least the specified width to be declared: INT8_C,
UINT8_C, INT16_C, UINT16_C, INT32_C, UINT32_C, INTMAX_C, UINTMAX_C.
</p>
<p>
The macros INT64_C and UINT64_C are also defined if the the macro BOOST_NO_INT64_T
is not defined.
</p>
<p>
The C99 macro __STDC_CONSTANT_MACROS is also defined as an artifact of the
implementation.
</p>
<p>
For example:
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cstdint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">// Here the constant 0x1FFFFFFFF has the correct suffix applied:</span>
<span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uint64_t</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">INT64_C</span><span class="special">(</span><span class="number">0</span><span class="identifier">x1FFFFFFFF</span><span class="special">);</span>
</pre>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2007 Beman Dawes, Vesa Karvonen, John
Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="boost_macro_reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="guidelines_for_boost_authors.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

6
doc/html/boost_config/guidelines_for_boost_authors.html
View File

@ -6,7 +6,7 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
<link rel="home" href="../index.html" title="Boost.Config">
<link rel="up" href="../index.html" title="Boost.Config">
<link rel="prev" href="boost_macro_reference.html" title="Boost Macro Reference">
<link rel="prev" href="cstdint.html" title="Standard Integer Types">
<link rel="next" href="rationale.html" title="Rationale">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@ -20,7 +20,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="boost_macro_reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
<a accesskey="p" href="cstdint.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
@ -371,7 +371,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="boost_macro_reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
<a accesskey="p" href="cstdint.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

18
doc/html/index.html
View File

@ -77,6 +77,22 @@
<dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_for_libraries_with_separate_source_code">Macros
for libraries with separate source code</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_config/cstdint.html">Standard Integer Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.overview">Overview</a></span></dt>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.rationale">Rationale</a></span></dt>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.ce"><span class="emphasis"><em>Caveat emptor</em></span></a></span></dt>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.exact_width_integer_types">Exact-width
integer types</a></span></dt>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.minimum_width_integer_types">Minimum-width
integer types</a></span></dt>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.fastest_minimum_width_integer_types">Fastest
minimum-width integer types</a></span></dt>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.greatest_width_integer_types">Greatest-width
integer types</a></span></dt>
<dt><span class="section"><a href="boost_config/cstdint.html#boost_config.cstdint.integer_constant_macros">Integer
Constant Macros</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_config/guidelines_for_boost_authors.html">Guidelines for
Boost Authors</a></span></dt>
<dd><dl>
@ -951,7 +967,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"><p><small>Last revised: December 12, 2013 at 19:29:48 GMT</small></p></td>
<td align="left"><p><small>Last revised: June 01, 2014 at 09:50:01 GMT</small></p></td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

28
doc/macro_reference.qbk
View File

@ -664,6 +664,10 @@ range-based for statements.
[[`BOOST_NO_CXX11_RAW_LITERALS`][The compiler does not support
raw string literals.
]]
[[`BOOST_NO_CXX11_REF_QUALIFIERS`][The compiler does not support
ref-qualifiers on member functions as described in
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm N2439].
]]
[[`BOOST_NO_CXX11_RVALUE_REFERENCES`][The compiler does not support
r-value references.
]]
@ -1064,7 +1068,7 @@ used to create a mangled name in combination with a predefined macro such a
]]
[[`BOOST_FORCEINLINE`][
This macro can be used in place of the `inline` keyword to instruct the compiler
that a function should always be inlined.
that the function should always be inlined.
Overuse of this macro can lead to significant bloat, while good use can increase
performance in certain cases, such as computation-intensive code built through
generative programming techniques.
@ -1084,7 +1088,7 @@ able to debug errors more easily.
]]
[[`BOOST_NOINLINE`][
This macro can be used in place of the `inline` keyword to instruct the compiler
that a function should never be inlined. One should typically use this macro
that the function should never be inlined. One should typically use this macro
to mark functions that are unlikely to be called, such as error handling routines.
Usage example:
@ -1095,6 +1099,26 @@ Usage example:
}
``
]]
[[`BOOST_NORETURN`][
This macro can be used before the function declaration or definition to instruct the compiler
that the function does not return normally (i.e. with a `return` statement or by leaving
the function scope, if the function return type is `void`). The macro can be used to mark
functions that always throw exceptions or terminate the application. Compilers that support
this markup may use this information to specifically organize the code surrounding calls to
this function and suppress warnings about missing `return` statements in the functions
enclosing such calls.
Usage example:
``
BOOST_NORETURN void on_error_occurred(const char* descr)
{
throw std::runtime_error(descr);
}
``
If the compiler does not support this markup, `BOOST_NORETURN` is defined empty and an
additional macro `BOOST_NO_NORETURN` is defined.
]]
[[`BOOST_LIKELY(X)`
`BOOST_UNLIKELY(X)`][
These macros communicate to the compiler that the conditional expression `X` is likely

1
include/boost/config/compiler/borland.hpp
View File

@ -194,6 +194,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#if __BORLANDC__ >= 0x590
# define BOOST_HAS_TR1_HASH

4
include/boost/config/compiler/clang.hpp
View File

@ -140,6 +140,10 @@
# define BOOST_NO_CXX11_RAW_LITERALS
#endif
#if !__has_feature(cxx_reference_qualified_functions)
# define BOOST_NO_CXX11_REF_QUALIFIERS
#endif
#if !__has_feature(cxx_generalized_initializers)
# define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#endif

1
include/boost/config/compiler/codegear.hpp
View File

@ -120,6 +120,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
//
// TR1 macros:

1
include/boost/config/compiler/common_edg.hpp
View File

@ -104,6 +104,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#ifdef c_plusplus
// EDG has "long long" in non-strict mode

1
include/boost/config/compiler/digitalmars.hpp
View File

@ -80,6 +80,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#if (__DMC__ <= 0x840)
#error "Compiler not supported or configured - please reconfigure"

1
include/boost/config/compiler/gcc.hpp
View File

@ -232,6 +232,7 @@
//
#if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40801) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
# define BOOST_NO_CXX11_DECLTYPE_N3276
# define BOOST_NO_CXX11_REF_QUALIFIERS
#endif
#ifndef BOOST_COMPILER

1
include/boost/config/compiler/gcc_xml.hpp
View File

@ -58,6 +58,7 @@
# define BOOST_NO_CXX11_ALIGNAS
# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
# define BOOST_NO_CXX11_INLINE_NAMESPACES
# define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__

1
include/boost/config/compiler/hp_acc.hpp
View File

@ -122,6 +122,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
/*
See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and

1
include/boost/config/compiler/intel.hpp
View File

@ -265,6 +265,7 @@ template<> struct assert_intrinsic_wchar_t<unsigned short> {};
# undef BOOST_NO_CXX11_HDR_THREAD
# undef BOOST_NO_CXX11_CHAR32_T
# undef BOOST_NO_CXX11_CHAR16_T
# undef BOOST_NO_CXX11_REF_QUALIFIERS
#endif
#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION <= 1310)

1
include/boost/config/compiler/metrowerks.hpp
View File

@ -123,6 +123,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)

2
include/boost/config/compiler/mpw.hpp
View File

@ -72,7 +72,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
//
// versions check:
// we don't support MPW prior to version 8.9:

1
include/boost/config/compiler/pathscale.hpp
View File

@ -80,4 +80,5 @@
# define BOOST_NO_CXX11_ALIGNAS
# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
# define BOOST_NO_CXX11_INLINE_NAMESPACES
# define BOOST_NO_CXX11_REF_QUALIFIERS
#endif

1
include/boost/config/compiler/pgi.hpp
View File

@ -118,6 +118,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
//
// version check:

1
include/boost/config/compiler/sunpro_cc.hpp
View File

@ -131,6 +131,7 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
//
// Version

1
include/boost/config/compiler/vacpp.hpp
View File

@ -129,3 +129,4 @@
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS

1
include/boost/config/compiler/visualc.hpp
View File

@ -173,6 +173,7 @@
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP

15
include/boost/config/suffix.hpp
View File

@ -603,6 +603,21 @@ namespace std{ using ::type_info; }
# endif
#endif
// BOOST_NORETURN ---------------------------------------------//
// Macro to use before a function declaration/definition to designate
// the function as not returning normally (i.e. with a return statement
// or by leaving the function scope, if the function return type is void).
#if !defined(BOOST_NORETURN)
# if defined(_MSC_VER)
# define BOOST_NORETURN __declspec(noreturn)
# elif defined(__GNUC__)
# define BOOST_NORETURN __attribute__ ((__noreturn__))
# else
# define BOOST_NO_NORETURN
# define BOOST_NORETURN
# endif
#endif
// Branch prediction hints
// These macros are intended to wrap conditional expressions that yield true or false
//

545
include/boost/cstdint.hpp Normal file
View File

@ -0,0 +1,545 @@
// boost cstdint.hpp header file ------------------------------------------//
// (C) Copyright Beman Dawes 1999.
// (C) Copyright Jens Mauer 2001
// (C) Copyright John Maddock 2001
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/integer for documentation.
// Revision History
// 31 Oct 01 use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
// 16 Apr 01 check LONGLONG_MAX when looking for "long long" (Jens Maurer)
// 23 Jan 01 prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
// 12 Nov 00 Merged <boost/stdint.h> (Jens Maurer)
// 23 Sep 00 Added INTXX_C macro support (John Maddock).
// 22 Sep 00 Better 64-bit support (John Maddock)
// 29 Jun 00 Reimplement to avoid including stdint.h within namespace boost
// 8 Aug 99 Initial version (Beman Dawes)
#ifndef BOOST_CSTDINT_HPP
#define BOOST_CSTDINT_HPP
//
// Since we always define the INT#_C macros as per C++0x,
// define __STDC_CONSTANT_MACROS so that <stdint.h> does the right
// thing if possible, and so that the user knows that the macros
// are actually defined as per C99.
//
#ifndef __STDC_CONSTANT_MACROS
# define __STDC_CONSTANT_MACROS
#endif
#include <boost/config.hpp>
//
// Note that GLIBC is a bit inconsistent about whether int64_t is defined or not
// depending upon what headers happen to have been included first...
// so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG.
// See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990
//
#if defined(BOOST_HAS_STDINT_H) \
&& (!defined(__GLIBC__) \
|| defined(__GLIBC_HAVE_LONG_LONG) \
|| (defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 17)))))
// The following #include is an implementation artifact; not part of interface.
# ifdef __hpux
// HP-UX has a vaguely nice <stdint.h> in a non-standard location
# include <inttypes.h>
# ifdef __STDC_32_MODE__
// this is triggered with GCC, because it defines __cplusplus < 199707L
# define BOOST_NO_INT64_T
# endif
# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
# include <inttypes.h>
# else
# include <stdint.h>
// There is a bug in Cygwin two _C macros
# if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__)
# undef INTMAX_C
# undef UINTMAX_C
# define INTMAX_C(c) c##LL
# define UINTMAX_C(c) c##ULL
# endif
# endif
#ifdef __QNX__
// QNX (Dinkumware stdlib) defines these as non-standard names.
// Reflect to the standard names.
typedef ::intleast8_t int_least8_t;
typedef ::intfast8_t int_fast8_t;
typedef ::uintleast8_t uint_least8_t;
typedef ::uintfast8_t uint_fast8_t;
typedef ::intleast16_t int_least16_t;
typedef ::intfast16_t int_fast16_t;
typedef ::uintleast16_t uint_least16_t;
typedef ::uintfast16_t uint_fast16_t;
typedef ::intleast32_t int_least32_t;
typedef ::intfast32_t int_fast32_t;
typedef ::uintleast32_t uint_least32_t;
typedef ::uintfast32_t uint_fast32_t;
# ifndef BOOST_NO_INT64_T
typedef ::intleast64_t int_least64_t;
typedef ::intfast64_t int_fast64_t;
typedef ::uintleast64_t uint_least64_t;
typedef ::uintfast64_t uint_fast64_t;
# endif
#endif
namespace boost
{
using ::int8_t;
using ::int_least8_t;
using ::int_fast8_t;
using ::uint8_t;
using ::uint_least8_t;
using ::uint_fast8_t;
using ::int16_t;
using ::int_least16_t;
using ::int_fast16_t;
using ::uint16_t;
using ::uint_least16_t;
using ::uint_fast16_t;
using ::int32_t;
using ::int_least32_t;
using ::int_fast32_t;
using ::uint32_t;
using ::uint_least32_t;
using ::uint_fast32_t;
# ifndef BOOST_NO_INT64_T
using ::int64_t;
using ::int_least64_t;
using ::int_fast64_t;
using ::uint64_t;
using ::uint_least64_t;
using ::uint_fast64_t;
# endif
using ::intmax_t;
using ::uintmax_t;
} // namespace boost
#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS)
// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
# include <inttypes.h>
namespace boost {
using ::int8_t;
typedef int8_t int_least8_t;
typedef int8_t int_fast8_t;
using ::uint8_t;
typedef uint8_t uint_least8_t;
typedef uint8_t uint_fast8_t;
using ::int16_t;
typedef int16_t int_least16_t;
typedef int16_t int_fast16_t;
using ::uint16_t;
typedef uint16_t uint_least16_t;
typedef uint16_t uint_fast16_t;
using ::int32_t;
typedef int32_t int_least32_t;
typedef int32_t int_fast32_t;
using ::uint32_t;
typedef uint32_t uint_least32_t;
typedef uint32_t uint_fast32_t;
# ifndef BOOST_NO_INT64_T
using ::int64_t;
typedef int64_t int_least64_t;
typedef int64_t int_fast64_t;
using ::uint64_t;
typedef uint64_t uint_least64_t;
typedef uint64_t uint_fast64_t;
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
# else
typedef int32_t intmax_t;
typedef uint32_t uintmax_t;
# endif
} // namespace boost
#else // BOOST_HAS_STDINT_H
# include <boost/limits.hpp> // implementation artifact; not part of interface
# include <limits.h> // needed for limits macros
namespace boost
{
// These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
// platforms. For other systems, they will have to be hand tailored.
//
// Because the fast types are assumed to be the same as the undecorated types,
// it may be possible to hand tailor a more efficient implementation. Such
// an optimization may be illusionary; on the Intel x86-family 386 on, for
// example, byte arithmetic and load/stores are as fast as "int" sized ones.
// 8-bit types ------------------------------------------------------------//
# if UCHAR_MAX == 0xff
typedef signed char int8_t;
typedef signed char int_least8_t;
typedef signed char int_fast8_t;
typedef unsigned char uint8_t;
typedef unsigned char uint_least8_t;
typedef unsigned char uint_fast8_t;
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
// 16-bit types -----------------------------------------------------------//
# if USHRT_MAX == 0xffff
# if defined(__crayx1)
// The Cray X1 has a 16-bit short, however it is not recommend
// for use in performance critical code.
typedef short int16_t;
typedef short int_least16_t;
typedef int int_fast16_t;
typedef unsigned short uint16_t;
typedef unsigned short uint_least16_t;
typedef unsigned int uint_fast16_t;
# else
typedef short int16_t;
typedef short int_least16_t;
typedef short int_fast16_t;
typedef unsigned short uint16_t;
typedef unsigned short uint_least16_t;
typedef unsigned short uint_fast16_t;
# endif
# elif (USHRT_MAX == 0xffffffff) && defined(__MTA__)
// On MTA / XMT short is 32 bits unless the -short16 compiler flag is specified
// MTA / XMT does support the following non-standard integer types
typedef __short16 int16_t;
typedef __short16 int_least16_t;
typedef __short16 int_fast16_t;
typedef unsigned __short16 uint16_t;
typedef unsigned __short16 uint_least16_t;
typedef unsigned __short16 uint_fast16_t;
# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
// no 16-bit types on Cray:
typedef short int_least16_t;
typedef short int_fast16_t;
typedef unsigned short uint_least16_t;
typedef unsigned short uint_fast16_t;
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
// 32-bit types -----------------------------------------------------------//
# if UINT_MAX == 0xffffffff
typedef int int32_t;
typedef int int_least32_t;
typedef int int_fast32_t;
typedef unsigned int uint32_t;
typedef unsigned int uint_least32_t;
typedef unsigned int uint_fast32_t;
# elif (USHRT_MAX == 0xffffffff)
typedef short int32_t;
typedef short int_least32_t;
typedef short int_fast32_t;
typedef unsigned short uint32_t;
typedef unsigned short uint_least32_t;
typedef unsigned short uint_fast32_t;
# elif ULONG_MAX == 0xffffffff
typedef long int32_t;
typedef long int_least32_t;
typedef long int_fast32_t;
typedef unsigned long uint32_t;
typedef unsigned long uint_least32_t;
typedef unsigned long uint_fast32_t;
# elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__)
// Integers are 64 bits on the MTA / XMT
typedef __int32 int32_t;
typedef __int32 int_least32_t;
typedef __int32 int_fast32_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int32 uint_least32_t;
typedef unsigned __int32 uint_fast32_t;
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
// 64-bit types + intmax_t and uintmax_t ----------------------------------//
# if defined(BOOST_HAS_LONG_LONG) && \
!defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
(!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
(defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
# if defined(__hpux)
// HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
# elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)
// 2**64 - 1
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
typedef ::boost::long_long_type intmax_t;
typedef ::boost::ulong_long_type uintmax_t;
typedef ::boost::long_long_type int64_t;
typedef ::boost::long_long_type int_least64_t;
typedef ::boost::long_long_type int_fast64_t;
typedef ::boost::ulong_long_type uint64_t;
typedef ::boost::ulong_long_type uint_least64_t;
typedef ::boost::ulong_long_type uint_fast64_t;
# elif ULONG_MAX != 0xffffffff
# if ULONG_MAX == 18446744073709551615 // 2**64 - 1
typedef long intmax_t;
typedef unsigned long uintmax_t;
typedef long int64_t;
typedef long int_least64_t;
typedef long int_fast64_t;
typedef unsigned long uint64_t;
typedef unsigned long uint_least64_t;
typedef unsigned long uint_fast64_t;
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
__extension__ typedef long long intmax_t;
__extension__ typedef unsigned long long uintmax_t;
__extension__ typedef long long int64_t;
__extension__ typedef long long int_least64_t;
__extension__ typedef long long int_fast64_t;
__extension__ typedef unsigned long long uint64_t;
__extension__ typedef unsigned long long uint_least64_t;
__extension__ typedef unsigned long long uint_fast64_t;
# elif defined(BOOST_HAS_MS_INT64)
//
// we have Borland/Intel/Microsoft __int64:
//
typedef __int64 intmax_t;
typedef unsigned __int64 uintmax_t;
typedef __int64 int64_t;
typedef __int64 int_least64_t;
typedef __int64 int_fast64_t;
typedef unsigned __int64 uint64_t;
typedef unsigned __int64 uint_least64_t;
typedef unsigned __int64 uint_fast64_t;
# else // assume no 64-bit integers
# define BOOST_NO_INT64_T
typedef int32_t intmax_t;
typedef uint32_t uintmax_t;
# endif
} // namespace boost
#endif // BOOST_HAS_STDINT_H
// intptr_t/uintptr_t are defined separately because they are optional and not universally available
#if defined(BOOST_WINDOWS) && !defined(_WIN32_WCE) && !defined(BOOST_HAS_STDINT_H)
// Older MSVC don't have stdint.h and have intptr_t/uintptr_t defined in stddef.h
#include <stddef.h>
#endif
// PGI seems to not support intptr_t/uintptr_t properly. BOOST_HAS_STDINT_H is not defined for this compiler by Boost.Config.
#if !defined(__PGIC__)
#if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \
|| (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \
|| defined(__CYGWIN__) \
|| defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \
|| defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
namespace boost {
using ::intptr_t;
using ::uintptr_t;
}
#define BOOST_HAS_INTPTR_T
// Clang pretends to be GCC, so it'll match this condition
#elif defined(__GNUC__) && defined(__INTPTR_TYPE__) && defined(__UINTPTR_TYPE__)
namespace boost {
typedef __INTPTR_TYPE__ intptr_t;
typedef __UINTPTR_TYPE__ uintptr_t;
}
#define BOOST_HAS_INTPTR_T
#endif
#endif // !defined(__PGIC__)
#endif // BOOST_CSTDINT_HPP
/****************************************************
Macro definition section:
Added 23rd September 2000 (John Maddock).
Modified 11th September 2001 to be excluded when
BOOST_HAS_STDINT_H is defined (John Maddock).
Modified 11th Dec 2009 to always define the
INT#_C macros if they're not already defined (John Maddock).
******************************************************/
#if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \
(!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C))
//
// For the following code we get several warnings along the lines of:
//
// boost/cstdint.hpp:428:35: error: use of C99 long long integer constant
//
// So we declare this a system header to suppress these warnings.
//
#if defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif
#include <limits.h>
# define BOOST__STDC_CONSTANT_MACROS_DEFINED
# if defined(BOOST_HAS_MS_INT64)
//
// Borland/Intel/Microsoft compilers have width specific suffixes:
//
#ifndef INT8_C
# define INT8_C(value) value##i8
#endif
#ifndef INT16_C
# define INT16_C(value) value##i16
#endif
#ifndef INT32_C
# define INT32_C(value) value##i32
#endif
#ifndef INT64_C
# define INT64_C(value) value##i64
#endif
# ifdef __BORLANDC__
// Borland bug: appending ui8 makes the type a signed char
# define UINT8_C(value) static_cast<unsigned char>(value##u)
# else
# define UINT8_C(value) value##ui8
# endif
#ifndef UINT16_C
# define UINT16_C(value) value##ui16
#endif
#ifndef UINT32_C
# define UINT32_C(value) value##ui32
#endif
#ifndef UINT64_C
# define UINT64_C(value) value##ui64
#endif
#ifndef INTMAX_C
# define INTMAX_C(value) value##i64
# define UINTMAX_C(value) value##ui64
#endif
# else
// do it the old fashioned way:
// 8-bit types ------------------------------------------------------------//
# if (UCHAR_MAX == 0xff) && !defined(INT8_C)
# define INT8_C(value) static_cast<boost::int8_t>(value)
# define UINT8_C(value) static_cast<boost::uint8_t>(value##u)
# endif
// 16-bit types -----------------------------------------------------------//
# if (USHRT_MAX == 0xffff) && !defined(INT16_C)
# define INT16_C(value) static_cast<boost::int16_t>(value)
# define UINT16_C(value) static_cast<boost::uint16_t>(value##u)
# endif
// 32-bit types -----------------------------------------------------------//
#ifndef INT32_C
# if (UINT_MAX == 0xffffffff)
# define INT32_C(value) value
# define UINT32_C(value) value##u
# elif ULONG_MAX == 0xffffffff
# define INT32_C(value) value##L
# define UINT32_C(value) value##uL
# endif
#endif
// 64-bit types + intmax_t and uintmax_t ----------------------------------//
#ifndef INT64_C
# if defined(BOOST_HAS_LONG_LONG) && \
(defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_LLONG_MAX))
# if defined(__hpux)
// HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
# define INT64_C(value) value##LL
# define UINT64_C(value) value##uLL
# elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || \
(defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || \
(defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \
(defined(_LLONG_MAX) && _LLONG_MAX == 18446744073709551615ULL)
# define INT64_C(value) value##LL
# define UINT64_C(value) value##uLL
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
# elif ULONG_MAX != 0xffffffff
# if ULONG_MAX == 18446744073709551615U // 2**64 - 1
# define INT64_C(value) value##L
# define UINT64_C(value) value##uL
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
# elif defined(BOOST_HAS_LONG_LONG)
// Usual macros not defined, work things out for ourselves:
# if(~0uLL == 18446744073709551615ULL)
# define INT64_C(value) value##LL
# define UINT64_C(value) value##uLL
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
# else
# error defaults not correct; you must hand modify boost/cstdint.hpp
# endif
# ifdef BOOST_NO_INT64_T
# define INTMAX_C(value) INT32_C(value)
# define UINTMAX_C(value) UINT32_C(value)
# else
# define INTMAX_C(value) INT64_C(value)
# define UINTMAX_C(value) UINT64_C(value)
# endif
#endif
# endif // Borland/Microsoft specific width suffixes
#endif // INT#_C macros.

3
test/Jamfile.v2
View File

@ -66,6 +66,9 @@ test-suite config
[ compile-fail threads/test_thread_fail1.cpp ]
[ compile-fail threads/test_thread_fail2.cpp ]
[ compile boost_fallthrough_test.cpp : [ check-target-builds has_clang_implicit_fallthrough "Clang implicit fallthrough" : <toolset>clang:<cxxflags>"-std=c++11 -Wimplicit-fallthrough" <warnings-as-errors>on <warnings>all ] ]
[ run cstdint_test.cpp : : : <warnings>all <toolset>gcc:<cxxflags>"-Wno-long-long -Wextra" <toolset>darwin:<cxxflags>-Wno-long-long ]
[ run cstdint_test2.cpp : : : <warnings>all <toolset>gcc:<cxxflags>"-Wno-long-long -Wextra" <toolset>darwin:<cxxflags>-Wno-long-long ]
[ compile cstdint_include_test.cpp : <warnings>all <toolset>gcc:<cxxflags>-Wextra ]
;
obj has_clang_implicit_fallthrough : cmd_line_check.cpp :

5
test/all/Jamfile.v2
View File

@ -1,7 +1,7 @@
#
# Regression test Jamfile for boost configuration setup.
# *** DO NOT EDIT THIS FILE BY HAND ***
# This file was automatically generated on Tue Feb 11 17:12:28 2014
# This file was automatically generated on Wed May 28 17:13:04 2014
# by libs/config/tools/generate.cpp
# Copyright John Maddock.
# Use, modification and distribution are subject to the
@ -301,6 +301,9 @@ test-suite "BOOST_NO_CXX11_INLINE_NAMESPACES" :
test-suite "BOOST_NO_CXX11_NUMERIC_LIMITS" :
[ run ../no_cxx11_numeric_limits_pass.cpp ]
[ compile-fail ../no_cxx11_numeric_limits_fail.cpp ] ;
test-suite "BOOST_NO_CXX11_REF_QUALIFIERS" :
[ run ../no_cxx11_ref_qualifiers_pass.cpp ]
[ compile-fail ../no_cxx11_ref_qualifiers_fail.cpp ] ;
test-suite "BOOST_NO_CXX11_SMART_PTR" :
[ run ../no_cxx11_smart_ptr_pass.cpp ]
[ compile-fail ../no_cxx11_smart_ptr_fail.cpp ] ;

1
test/boost_has_pthread_yield.ipp
View File

@ -18,6 +18,7 @@ void f()
{
// this is never called, it just has to compile:
int res = pthread_yield();
(void)res;
}
int test()

4
test/boost_no_cxx11_hdr_regex.ipp
View File

@ -1,5 +1,5 @@
// (C) Copyright Beman Dawes 2009
// Copyright (c) Microsoft Corporation
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@ -20,7 +20,7 @@ int test()
using std::wregex;
regex e("\\d+");
wregex we(L"\\s+");
wregex we(L"\\d+");
std::string s("123456");
std::wstring ws(L"123456");
return regex_match(s, e) && regex_match(ws, we) ? 0 : 1;

33
test/boost_no_cxx11_ref_qualifiers.ipp Normal file
View File

@ -0,0 +1,33 @@
// (C) Copyright Andrzej Krzemienski 2014
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/config for more information.
// MACRO: BOOST_NO_CXX11_REF_QUALIFIERS
// TITLE: C++11 ref-qualifiers on member functions.
// DESCRIPTION: The compiler does not support the C++11 ref-qualifiers on member functions as described in N2439.
namespace boost_no_cxx11_ref_qualifiers {
struct G
{
char get() & { return 'l'; }
char get() && { return 'r'; }
char get() const& { return 'c'; }
};
int test()
{
G m;
const G c = G();
if (m.get() != 'l') return 1;
if (c.get() != 'c') return 1;
if (G().get() != 'r') return 1;
return 0;
}
}

2
test/boost_no_lambdas.ipp
View File

@ -18,7 +18,7 @@ namespace boost_no_cxx11_lambdas {
int test()
{
[](){};
(void)[](){};
return 0;
}

2
test/boost_no_std_allocator.ipp
View File

@ -53,6 +53,8 @@ int test_allocator(const T& i)
// and isn't currently required by anything in boost
// so don't test for now...
// a3 = a2;
(void)a2;
return 0;
}

2
test/boost_no_unified_init.ipp
View File

@ -23,6 +23,8 @@ struct AltStruct
{
public:
AltStruct(int x, double y) : x_{x}, y_{y} {}
int X() const { return x_; }
double Y() const { return y_; }
private:
int x_;
double y_;

2
test/config_info.cpp
View File

@ -1036,6 +1036,7 @@ void print_boost_macros()
PRINT_MACRO(BOOST_NO_CXX11_NUMERIC_LIMITS);
PRINT_MACRO(BOOST_NO_CXX11_RANGE_BASED_FOR);
PRINT_MACRO(BOOST_NO_CXX11_RAW_LITERALS);
PRINT_MACRO(BOOST_NO_CXX11_REF_QUALIFIERS);
PRINT_MACRO(BOOST_NO_CXX11_RVALUE_REFERENCES);
PRINT_MACRO(BOOST_NO_CXX11_SCOPED_ENUMS);
PRINT_MACRO(BOOST_NO_CXX11_SMART_PTR);
@ -1117,6 +1118,7 @@ void print_boost_macros()
// END GENERATED BLOCK
PRINT_MACRO(BOOST_INTEL);

12
test/config_test.cpp
View File

@ -1,4 +1,4 @@
// This file was automatically generated on Tue Feb 11 17:12:28 2014
// This file was automatically generated on Wed May 28 17:13:04 2014
// by libs/config/tools/generate.cpp
// Copyright John Maddock 2002-4.
// Use, modification and distribution are subject to the
@ -227,6 +227,11 @@ namespace boost_no_cxx11_inline_namespaces = empty_boost;
#else
namespace boost_no_cxx11_numeric_limits = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
#include "boost_no_cxx11_ref_qualifiers.ipp"
#else
namespace boost_no_cxx11_ref_qualifiers = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
#include "boost_no_cxx11_smart_ptr.ipp"
#else
@ -1386,6 +1391,11 @@ int main( int, char *[] )
std::cerr << "Failed test for BOOST_NO_CXX11_NUMERIC_LIMITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
++error_count;
}
if(0 != boost_no_cxx11_ref_qualifiers::test())
{
std::cerr << "Failed test for BOOST_NO_CXX11_REF_QUALIFIERS at: " << __FILE__ << ":" << __LINE__ << std::endl;
++error_count;
}
if(0 != boost_no_cxx11_smart_ptr::test())
{
std::cerr << "Failed test for BOOST_NO_CXX11_SMART_PTR at: " << __FILE__ << ":" << __LINE__ << std::endl;

69
test/cstdint_include_test.cpp Normal file
View File

@ -0,0 +1,69 @@
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#define __STDC_CONSTANT_MACROS
#include <boost/cstdint.hpp> // must be the only #include!
int main()
{
boost::int8_t i8 = INT8_C(0);
(void)i8;
boost::uint8_t ui8 = UINT8_C(0);
(void)ui8;
boost::int16_t i16 = INT16_C(0);
(void)i16;
boost::uint16_t ui16 = UINT16_C(0);
(void)ui16;
boost::int32_t i32 = INT32_C(0);
(void)i32;
boost::uint32_t ui32 = UINT32_C(0);
(void)ui32;
#ifndef BOOST_NO_INT64_T
boost::int64_t i64 = 0;
(void)i64;
boost::uint64_t ui64 = 0;
(void)ui64;
#endif
boost::int_least8_t i8least = INT8_C(0);
(void)i8least;
boost::uint_least8_t ui8least = UINT8_C(0);
(void)ui8least;
boost::int_least16_t i16least = INT16_C(0);
(void)i16least;
boost::uint_least16_t ui16least = UINT16_C(0);
(void)ui16least;
boost::int_least32_t i32least = INT32_C(0);
(void)i32least;
boost::uint_least32_t ui32least = UINT32_C(0);
(void)ui32least;
#ifndef BOOST_NO_INT64_T
boost::int_least64_t i64least = 0;
(void)i64least;
boost::uint_least64_t ui64least = 0;
(void)ui64least;
#endif
boost::int_fast8_t i8fast = INT8_C(0);
(void)i8fast;
boost::uint_fast8_t ui8fast = UINT8_C(0);
(void)ui8fast;
boost::int_fast16_t i16fast = INT16_C(0);
(void)i16fast;
boost::uint_fast16_t ui16fast = UINT16_C(0);
(void)ui16fast;
boost::int_fast32_t i32fast = INT32_C(0);
(void)i32fast;
boost::uint_fast32_t ui32fast = UINT32_C(0);
(void)ui32fast;
#ifndef BOOST_NO_INT64_T
boost::int_fast64_t i64fast = 0;
(void)i64fast;
boost::uint_fast64_t ui64fast = 0;
(void)ui64fast;
#endif
boost::intmax_t im = 0;
(void)im;
boost::uintmax_t uim = 0;
(void)uim;
}

238
test/cstdint_test.cpp Normal file
View File

@ -0,0 +1,238 @@
// boost cstdint.hpp test program ------------------------------------------//
// Copyright Beman Dawes 2000. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/integer for documentation.
// Revision History
// 11 Sep 01 Adapted to work with macros defined in native stdint.h (John Maddock)
// 12 Nov 00 Adapted to merged <boost/cstdint.hpp>
// 23 Sep 00 Added INTXX_C constant macro support + int64_t support (John Maddock).
// 28 Jun 00 Initial version
//
// There are two ways to test this: in version 1, we include cstdint.hpp as the first
// include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
// In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
// and check that we still end up with compatible definitions for the INT#_C macros.
//
// This is version 1.
//
#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
// We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
#pragma GCC diagnostic ignored "-Wtype-limits"
#endif
#include <boost/cstdint.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <iostream>
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
//
// the following class is designed to verify
// that the various INTXX_C macros can be used
// in integral constant expressions:
//
struct integral_constant_checker
{
static const boost::int8_t int8 = INT8_C(-127);
static const boost::int_least8_t int_least8 = INT8_C(-127);
static const boost::int_fast8_t int_fast8 = INT8_C(-127);
static const boost::uint8_t uint8 = UINT8_C(255);
static const boost::uint_least8_t uint_least8 = UINT8_C(255);
static const boost::uint_fast8_t uint_fast8 = UINT8_C(255);
static const boost::int16_t int16 = INT16_C(-32767);
static const boost::int_least16_t int_least16 = INT16_C(-32767);
static const boost::int_fast16_t int_fast16 = INT16_C(-32767);
static const boost::uint16_t uint16 = UINT16_C(65535);
static const boost::uint_least16_t uint_least16 = UINT16_C(65535);
static const boost::uint_fast16_t uint_fast16 = UINT16_C(65535);
static const boost::int32_t int32 = INT32_C(-2147483647);
static const boost::int_least32_t int_least32 = INT32_C(-2147483647);
static const boost::int_fast32_t int_fast32 = INT32_C(-2147483647);
static const boost::uint32_t uint32 = UINT32_C(4294967295);
static const boost::uint_least32_t uint_least32 = UINT32_C(4294967295);
static const boost::uint_fast32_t uint_fast32 = UINT32_C(4294967295);
static void check();
};
void integral_constant_checker::check()
{
BOOST_TEST( int8 == -127 );
BOOST_TEST( int_least8 == -127 );
BOOST_TEST( int_fast8 == -127 );
BOOST_TEST( uint8 == 255u );
BOOST_TEST( uint_least8 == 255u );
BOOST_TEST( uint_fast8 == 255u );
BOOST_TEST( int16 == -32767 );
BOOST_TEST( int_least16 == -32767 );
BOOST_TEST( int_fast16 == -32767 );
BOOST_TEST( uint16 == 65535u );
BOOST_TEST( uint_least16 == 65535u );
BOOST_TEST( uint_fast16 == 65535u );
BOOST_TEST( int32 == -2147483647 );
BOOST_TEST( int_least32 == -2147483647 );
BOOST_TEST( int_fast32 == -2147483647 );
BOOST_TEST( uint32 == 4294967295u );
BOOST_TEST( uint_least32 == 4294967295u );
BOOST_TEST( uint_fast32 == 4294967295u );
}
#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
//
// the following function simply verifies that the type
// of an integral constant is correctly defined:
//
#ifdef __BORLANDC__
#pragma option -w-8008
#pragma option -w-8066
#endif
template <class T1, class T2>
void integral_constant_type_check(T1, T2)
{
//
// the types T1 and T2 may not be exactly
// the same type, but they should be the
// same size and signedness. We could use
// numeric_limits to verify this, but
// numeric_limits implementations currently
// vary too much, or are incomplete or missing.
//
T1 t1 = static_cast<T1>(-1); // cast suppresses warnings
T2 t2 = static_cast<T2>(-1); // ditto
#if defined(BOOST_HAS_STDINT_H)
// if we have a native stdint.h
// then the INTXX_C macros may define
// a type that's wider than required:
BOOST_TEST(sizeof(T1) <= sizeof(T2));
#else
BOOST_TEST(sizeof(T1) == sizeof(T2));
BOOST_TEST(t1 == t2);
#endif
#if defined(BOOST_HAS_STDINT_H)
// native headers are permitted to promote small
// unsigned types to type int:
if(sizeof(T1) >= sizeof(int))
{
if(t1 > 0)
BOOST_TEST(t2 > 0);
else
BOOST_TEST(!(t2 > 0));
}
else if(t1 < 0)
BOOST_TEST(!(t2 > 0));
#else
if(t1 > 0)
BOOST_TEST(t2 > 0);
else
BOOST_TEST(!(t2 > 0));
#endif
}
int main(int, char*[])
{
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
integral_constant_checker::check();
#endif
//
// verify the types of the integral constants:
//
integral_constant_type_check(boost::int8_t(0), INT8_C(0));
integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
integral_constant_type_check(boost::int16_t(0), INT16_C(0));
integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
integral_constant_type_check(boost::int32_t(0), INT32_C(0));
integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
#ifndef BOOST_NO_INT64_T
integral_constant_type_check(boost::int64_t(0), INT64_C(0));
integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
#endif
//
boost::int8_t int8 = INT8_C(-127);
boost::int_least8_t int_least8 = INT8_C(-127);
boost::int_fast8_t int_fast8 = INT8_C(-127);
boost::uint8_t uint8 = UINT8_C(255);
boost::uint_least8_t uint_least8 = UINT8_C(255);
boost::uint_fast8_t uint_fast8 = UINT8_C(255);
boost::int16_t int16 = INT16_C(-32767);
boost::int_least16_t int_least16 = INT16_C(-32767);
boost::int_fast16_t int_fast16 = INT16_C(-32767);
boost::uint16_t uint16 = UINT16_C(65535);
boost::uint_least16_t uint_least16 = UINT16_C(65535);
boost::uint_fast16_t uint_fast16 = UINT16_C(65535);
boost::int32_t int32 = INT32_C(-2147483647);
boost::int_least32_t int_least32 = INT32_C(-2147483647);
boost::int_fast32_t int_fast32 = INT32_C(-2147483647);
boost::uint32_t uint32 = UINT32_C(4294967295);
boost::uint_least32_t uint_least32 = UINT32_C(4294967295);
boost::uint_fast32_t uint_fast32 = UINT32_C(4294967295);
#ifndef BOOST_NO_INT64_T
boost::int64_t int64 = INT64_C(-9223372036854775807);
boost::int_least64_t int_least64 = INT64_C(-9223372036854775807);
boost::int_fast64_t int_fast64 = INT64_C(-9223372036854775807);
boost::uint64_t uint64 = UINT64_C(18446744073709551615);
boost::uint_least64_t uint_least64 = UINT64_C(18446744073709551615);
boost::uint_fast64_t uint_fast64 = UINT64_C(18446744073709551615);
boost::intmax_t intmax = INTMAX_C(-9223372036854775807);
boost::uintmax_t uintmax = UINTMAX_C(18446744073709551615);
#else
boost::intmax_t intmax = INTMAX_C(-2147483647);
boost::uintmax_t uintmax = UINTMAX_C(4294967295);
#endif
BOOST_TEST( int8 == -127 );
BOOST_TEST( int_least8 == -127 );
BOOST_TEST( int_fast8 == -127 );
BOOST_TEST( uint8 == 255u );
BOOST_TEST( uint_least8 == 255u );
BOOST_TEST( uint_fast8 == 255u );
BOOST_TEST( int16 == -32767 );
BOOST_TEST( int_least16 == -32767 );
BOOST_TEST( int_fast16 == -32767 );
BOOST_TEST( uint16 == 65535u );
BOOST_TEST( uint_least16 == 65535u );
BOOST_TEST( uint_fast16 == 65535u );
BOOST_TEST( int32 == -2147483647 );
BOOST_TEST( int_least32 == -2147483647 );
BOOST_TEST( int_fast32 == -2147483647 );
BOOST_TEST( uint32 == 4294967295u );
BOOST_TEST( uint_least32 == 4294967295u );
BOOST_TEST( uint_fast32 == 4294967295u );
#ifndef BOOST_NO_INT64_T
BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
#else
BOOST_TEST( intmax == -2147483647 );
BOOST_TEST( uintmax == 4294967295u );
#endif
std::cout << "OK\n";
return boost::report_errors();
}

248
test/cstdint_test2.cpp Normal file
View File

@ -0,0 +1,248 @@
// boost cstdint.hpp test program ------------------------------------------//
// Copyright Beman Dawes 2000. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/integer for documentation.
// Revision History
// 11 Sep 01 Adapted to work with macros defined in native stdint.h (John Maddock)
// 12 Nov 00 Adapted to merged <boost/cstdint.hpp>
// 23 Sep 00 Added INTXX_C constant macro support + int64_t support (John Maddock).
// 28 Jun 00 Initial version
//
// There are two ways to test this: in version 1, we include cstdint.hpp as the first
// include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
// In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
// and check that we still end up with compatible definitions for the INT#_C macros.
//
// This is version 2.
//
#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
// We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
#pragma GCC diagnostic ignored "-Wtype-limits"
#endif
#include <boost/config.hpp>
#ifdef BOOST_HAS_STDINT_H
#ifdef __hpux
# include <inttypes.h>
#else
# include <stdint.h>
#endif
#endif
#include <boost/cstdint.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <iostream>
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
//
// the following class is designed to verify
// that the various INTXX_C macros can be used
// in integral constant expressions:
//
struct integral_constant_checker
{
static const boost::int8_t int8 = INT8_C(-127);
static const boost::int_least8_t int_least8 = INT8_C(-127);
static const boost::int_fast8_t int_fast8 = INT8_C(-127);
static const boost::uint8_t uint8 = UINT8_C(255);
static const boost::uint_least8_t uint_least8 = UINT8_C(255);
static const boost::uint_fast8_t uint_fast8 = UINT8_C(255);
static const boost::int16_t int16 = INT16_C(-32767);
static const boost::int_least16_t int_least16 = INT16_C(-32767);
static const boost::int_fast16_t int_fast16 = INT16_C(-32767);
static const boost::uint16_t uint16 = UINT16_C(65535);
static const boost::uint_least16_t uint_least16 = UINT16_C(65535);
static const boost::uint_fast16_t uint_fast16 = UINT16_C(65535);
static const boost::int32_t int32 = INT32_C(-2147483647);
static const boost::int_least32_t int_least32 = INT32_C(-2147483647);
static const boost::int_fast32_t int_fast32 = INT32_C(-2147483647);
static const boost::uint32_t uint32 = UINT32_C(4294967295);
static const boost::uint_least32_t uint_least32 = UINT32_C(4294967295);
static const boost::uint_fast32_t uint_fast32 = UINT32_C(4294967295);
static void check();
};
void integral_constant_checker::check()
{
BOOST_TEST( int8 == -127 );
BOOST_TEST( int_least8 == -127 );
BOOST_TEST( int_fast8 == -127 );
BOOST_TEST( uint8 == 255u );
BOOST_TEST( uint_least8 == 255u );
BOOST_TEST( uint_fast8 == 255u );
BOOST_TEST( int16 == -32767 );
BOOST_TEST( int_least16 == -32767 );
BOOST_TEST( int_fast16 == -32767 );
BOOST_TEST( uint16 == 65535u );
BOOST_TEST( uint_least16 == 65535u );
BOOST_TEST( uint_fast16 == 65535u );
BOOST_TEST( int32 == -2147483647 );
BOOST_TEST( int_least32 == -2147483647 );
BOOST_TEST( int_fast32 == -2147483647 );
BOOST_TEST( uint32 == 4294967295u );
BOOST_TEST( uint_least32 == 4294967295u );
BOOST_TEST( uint_fast32 == 4294967295u );
}
#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
//
// the following function simply verifies that the type
// of an integral constant is correctly defined:
//
#ifdef __BORLANDC__
#pragma option -w-8008
#pragma option -w-8066
#endif
template <class T1, class T2>
void integral_constant_type_check(T1, T2)
{
//
// the types T1 and T2 may not be exactly
// the same type, but they should be the
// same size and signedness. We could use
// numeric_limits to verify this, but
// numeric_limits implementations currently
// vary too much, or are incomplete or missing.
//
T1 t1 = static_cast<T1>(-1); // cast suppresses warnings
T2 t2 = static_cast<T2>(-1); // ditto
#if defined(BOOST_HAS_STDINT_H)
// if we have a native stdint.h
// then the INTXX_C macros may define
// a type that's wider than required:
BOOST_TEST(sizeof(T1) <= sizeof(T2));
#else
BOOST_TEST(sizeof(T1) == sizeof(T2));
BOOST_TEST(t1 == t2);
#endif
#if defined(BOOST_HAS_STDINT_H)
// native headers are permitted to promote small
// unsigned types to type int:
if(sizeof(T1) >= sizeof(int))
{
if(t1 > 0)
BOOST_TEST(t2 > 0);
else
BOOST_TEST(!(t2 > 0));
}
else if(t1 < 0)
BOOST_TEST(!(t2 > 0));
#else
if(t1 > 0)
BOOST_TEST(t2 > 0);
else
BOOST_TEST(!(t2 > 0));
#endif
}
int main(int, char*[])
{
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
integral_constant_checker::check();
#endif
//
// verify the types of the integral constants:
//
integral_constant_type_check(boost::int8_t(0), INT8_C(0));
integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
integral_constant_type_check(boost::int16_t(0), INT16_C(0));
integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
integral_constant_type_check(boost::int32_t(0), INT32_C(0));
integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
#ifndef BOOST_NO_INT64_T
integral_constant_type_check(boost::int64_t(0), INT64_C(0));
integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
#endif
//
boost::int8_t int8 = INT8_C(-127);
boost::int_least8_t int_least8 = INT8_C(-127);
boost::int_fast8_t int_fast8 = INT8_C(-127);
boost::uint8_t uint8 = UINT8_C(255);
boost::uint_least8_t uint_least8 = UINT8_C(255);
boost::uint_fast8_t uint_fast8 = UINT8_C(255);
boost::int16_t int16 = INT16_C(-32767);
boost::int_least16_t int_least16 = INT16_C(-32767);
boost::int_fast16_t int_fast16 = INT16_C(-32767);
boost::uint16_t uint16 = UINT16_C(65535);
boost::uint_least16_t uint_least16 = UINT16_C(65535);
boost::uint_fast16_t uint_fast16 = UINT16_C(65535);
boost::int32_t int32 = INT32_C(-2147483647);
boost::int_least32_t int_least32 = INT32_C(-2147483647);
boost::int_fast32_t int_fast32 = INT32_C(-2147483647);
boost::uint32_t uint32 = UINT32_C(4294967295);
boost::uint_least32_t uint_least32 = UINT32_C(4294967295);
boost::uint_fast32_t uint_fast32 = UINT32_C(4294967295);
#ifndef BOOST_NO_INT64_T
boost::int64_t int64 = INT64_C(-9223372036854775807);
boost::int_least64_t int_least64 = INT64_C(-9223372036854775807);
boost::int_fast64_t int_fast64 = INT64_C(-9223372036854775807);
boost::uint64_t uint64 = UINT64_C(18446744073709551615);
boost::uint_least64_t uint_least64 = UINT64_C(18446744073709551615);
boost::uint_fast64_t uint_fast64 = UINT64_C(18446744073709551615);
boost::intmax_t intmax = INTMAX_C(-9223372036854775807);
boost::uintmax_t uintmax = UINTMAX_C(18446744073709551615);
#else
boost::intmax_t intmax = INTMAX_C(-2147483647);
boost::uintmax_t uintmax = UINTMAX_C(4294967295);
#endif
BOOST_TEST( int8 == -127 );
BOOST_TEST( int_least8 == -127 );
BOOST_TEST( int_fast8 == -127 );
BOOST_TEST( uint8 == 255u );
BOOST_TEST( uint_least8 == 255u );
BOOST_TEST( uint_fast8 == 255u );
BOOST_TEST( int16 == -32767 );
BOOST_TEST( int_least16 == -32767 );
BOOST_TEST( int_fast16 == -32767 );
BOOST_TEST( uint16 == 65535u );
BOOST_TEST( uint_least16 == 65535u );
BOOST_TEST( uint_fast16 == 65535u );
BOOST_TEST( int32 == -2147483647 );
BOOST_TEST( int_least32 == -2147483647 );
BOOST_TEST( int_fast32 == -2147483647 );
BOOST_TEST( uint32 == 4294967295u );
BOOST_TEST( uint_least32 == 4294967295u );
BOOST_TEST( uint_fast32 == 4294967295u );
#ifndef BOOST_NO_INT64_T
BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
#else
BOOST_TEST( intmax == -2147483647 );
BOOST_TEST( uintmax == 4294967295u );
#endif
std::cout << "OK\n";
return boost::report_errors();
}

37
test/no_cxx11_ref_qualifiers_fail.cpp Normal file
View File

@ -0,0 +1,37 @@
// This file was automatically generated on Wed May 28 17:13:04 2014
// by libs/config/tools/generate.cpp
// Copyright John Maddock 2002-4.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/config for the most recent version.//
// Revision $Id$
//
// Test file for macro BOOST_NO_CXX11_REF_QUALIFIERS
// This file should not compile, if it does then
// BOOST_NO_CXX11_REF_QUALIFIERS should not be defined.
// See file boost_no_cxx11_ref_qualifiers.ipp for details
// Must not have BOOST_ASSERT_CONFIG set; it defeats
// the objective of this file:
#ifdef BOOST_ASSERT_CONFIG
# undef BOOST_ASSERT_CONFIG
#endif
#include <boost/config.hpp>
#include "test.hpp"
#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
#include "boost_no_cxx11_ref_qualifiers.ipp"
#else
#error "this file should not compile"
#endif
int main( int, char *[] )
{
return boost_no_cxx11_ref_qualifiers::test();
}

37
test/no_cxx11_ref_qualifiers_pass.cpp Normal file
View File

@ -0,0 +1,37 @@
// This file was automatically generated on Wed May 28 17:13:04 2014
// by libs/config/tools/generate.cpp
// Copyright John Maddock 2002-4.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/config for the most recent version.//
// Revision $Id$
//
// Test file for macro BOOST_NO_CXX11_REF_QUALIFIERS
// This file should compile, if it does not then
// BOOST_NO_CXX11_REF_QUALIFIERS should be defined.
// See file boost_no_cxx11_ref_qualifiers.ipp for details
// Must not have BOOST_ASSERT_CONFIG set; it defeats
// the objective of this file:
#ifdef BOOST_ASSERT_CONFIG
# undef BOOST_ASSERT_CONFIG
#endif
#include <boost/config.hpp>
#include "test.hpp"
#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
#include "boost_no_cxx11_ref_qualifiers.ipp"
#else
namespace boost_no_cxx11_ref_qualifiers = empty_boost;
#endif
int main( int, char *[] )
{
return boost_no_cxx11_ref_qualifiers::test();
}